ruby-cbc 0.1.9 → 0.2.1

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

@@ -1,280 +0,0 @@
-/* $Id: CoinOslFactorization.hpp 1416 2011-04-17 09:57:29Z stefan $ */
-// Copyright (C) 1987, 2009, 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 CoinOslFactorization_H
-#define CoinOslFactorization_H
-#include <iostream>
-#include <string>
-#include <cassert>
-#include "CoinTypes.hpp"
-#include "CoinIndexedVector.hpp"
-#include "CoinDenseFactorization.hpp"
-class CoinPackedMatrix;
-/** This deals with Factorization and Updates
-    This is ripped off from OSL!!!!!!!!!
-
-    I am assuming that 32 bits is enough for number of rows or columns, but CoinBigIndex
-    may be redefined to get 64 bits.
- */
-
-typedef struct {int suc, pre;} EKKHlink;
-typedef struct _EKKfactinfo {
-  double drtpiv;
-  double demark;
-  double zpivlu;
-  double zeroTolerance;
-  double areaFactor;
-  int *xrsadr;
-  int *xcsadr;
-  int *xrnadr;
-  int *xcnadr;
-  int *krpadr;
-  int *kcpadr;
-  int *mpermu;
-  int *bitArray;
-  int * back;
-  char * nonzero;
-  double * trueStart;
-  mutable double *kadrpm;
-  int *R_etas_index;
-  int *R_etas_start;
-  double *R_etas_element;
-
-  int *xecadr;
-  int *xeradr;
-  double *xeeadr;
-  double *xe2adr;
-  EKKHlink * kp1adr;
-  EKKHlink * kp2adr;
-  double * kw1adr;
-  double * kw2adr;
-  double * kw3adr;
-  int * hpivcoR;
-  int nrow;
-  int nrowmx;
-  int firstDoRow;
-  int firstLRow;
-  int maxinv;
-  int nnetas;
-  int iterin;
-  int iter0;
-  int invok;
-  int nbfinv;
-  int num_resets;
-  int nnentl;
-  int nnentu;
-#ifdef CLP_REUSE_ETAS
-  int save_nnentu;
-#endif
-  int ndenuc;
-  int npivots; /* use as xpivsq in factorization */
-  int kmxeta;
-  int xnetal;
-  int first_dense;
-  int last_dense;
-  int iterno;
-  int numberSlacks;
-  int lastSlack;
-  int firstNonSlack;
-  int xnetalval;
-  int lstart;
-  int if_sparse_update;
-  mutable int packedMode;
-  int switch_off_sparse_update;
-  int nuspike;
-  bool rows_ok;	/* replaces test using mrstrt[1] */
-#ifdef CLP_REUSE_ETAS
-  mutable int reintro;
-#endif
-  int nR_etas;
-  int sortedEta; /* if vector for F-T is sorted */
-  int lastEtaCount;
-  int ifvsol;
-  int eta_size;
-  int last_eta_size;
-  int maxNNetas;
-} EKKfactinfo;
-
-class CoinOslFactorization : public CoinOtherFactorization {
-   friend void CoinOslFactorizationUnitTest( const std::string & mpsDir );
-
-public:
-
-  /**@name Constructors and destructor and copy */
-  //@{
-  /// Default constructor
-  CoinOslFactorization (  );
-  /// Copy constructor 
-  CoinOslFactorization ( const CoinOslFactorization &other);
-  
-  /// Destructor
-  virtual ~CoinOslFactorization (  );
-  /// = copy
-  CoinOslFactorization & operator = ( const CoinOslFactorization & 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);
-  /** 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 );
-  //@}
-
-  /**@name general stuff such as number of elements */
-  //@{ 
-  /// Total number of elements in factorization
-  virtual inline int numberElements (  ) const {
-    return numberRows_*(numberColumns_+numberPivots_);
-  }
-  /// 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;
-  /// 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);
-  /// Set maximum pivots
-  virtual void maximumPivots (  int value );
-
-  /// Returns maximum absolute value in factorization
-  double maximumCoefficient() const;
-  /// Condition number - product of pivots after factorization
-  double conditionNumber() const;
-  /// Get rid of all memory
-  virtual void clearArrays();
-  //@}
-
-  /**@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 int updateColumnFT ( CoinIndexedVector * regionSparse,
-				      CoinIndexedVector * regionSparse2,
-				      bool noPermute=false);
-  /** 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 int * indices() const;
-  /// Returns permute in
-  virtual inline int * permute() const
-  { return NULL;/*pivotRow_*/;}
-  //@}
-
-  /// The real work of desstructor 
-  void gutsOfDestructor(bool clearFact=true);
-  /// The real work of constructor
-  void gutsOfInitialize(bool zapFact=true);
-  /// The real work of copy
-  void gutsOfCopy(const CoinOslFactorization &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 */
-  //@{
-  /// Osl factorization data
-  EKKfactinfo factInfo_;
-  //@}
-};
-#endif

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

@@ -1,947 +0,0 @@
-/* $Id: CoinPackedMatrix.hpp 1560 2012-11-24 00:29:01Z lou $ */
-// Copyright (C) 2000, International Business Machines
-// Corporation and others.  All Rights Reserved.
-// This code is licensed under the terms of the Eclipse Public License (EPL).
-
-#ifndef CoinPackedMatrix_H
-#define CoinPackedMatrix_H
-
-#include "CoinError.hpp"
-#include "CoinTypes.hpp"
-#ifndef CLP_NO_VECTOR
-#include "CoinPackedVectorBase.hpp"
-#include "CoinShallowPackedVector.hpp"
-#else
-class CoinRelFltEq;
-#endif
-
-/** Sparse Matrix Base Class
-
-  This class is intended to represent sparse matrices using row-major
-  or column-major ordering. The representation is very efficient for
-  adding, deleting, or retrieving major-dimension vectors. Adding
-  a minor-dimension vector is less efficient, but can be helped by
-  providing "extra" space as described in the next paragraph. Deleting
-  a minor-dimension vector requires inspecting all coefficients in the
-  matrix. Retrieving a minor-dimension vector would incur the same cost
-  and is not supported (except in the sense that you can write a loop to
-  retrieve all coefficients one at a time). Consider physically transposing
-  the matrix, or keeping a second copy with the other major-vector ordering.
-
-  The sparse represention can be completely compact or it can have "extra"
-  space available at the end of each major vector.  Incorporating extra
-  space into the sparse matrix representation can improve performance in
-  cases where new data needs to be inserted into the packed matrix against
-  the major-vector orientation (e.g, inserting a row into a matrix stored
-  in column-major order).
-
-  For example if the matrix:
-  @verbatim
-     3  1  0   -2   -1  0  0   -1                 
-     0  2  1.1  0    0  0  0    0                       
-     0  0  1    0    0  1  0    0         
-     0  0  0    2.8  0  0 -1.2  0   
-   5.6  0  0    0    1  0  0    1.9
-
-  was stored by rows (with no extra space) in 
-  CoinPackedMatrix r then: 
-    r.getElements() returns a vector containing: 
-      3 1 -2 -1 -1 2 1.1 1 1 2.8 -1.2 5.6 1 1.9 
-    r.getIndices() returns a vector containing: 
-      0 1  3  4  7 1 2   2 5 3    6   0   4 7 
-    r.getVectorStarts() returns a vector containing: 
-      0 5 7 9 11 14 
-    r.getNumElements() returns 14. 
-    r.getMajorDim() returns 5. 
-    r.getVectorSize(0) returns 5. 
-    r.getVectorSize(1) returns 2. 
-    r.getVectorSize(2) returns 2. 
-    r.getVectorSize(3) returns 2. 
-    r.getVectorSize(4) returns 3. 
- 
-  If stored by columns (with no extra space) then: 
-    c.getElements() returns a vector containing: 
-      3 5.6 1 2 1.1 1 -2 2.8 -1 1 1 -1.2 -1 1.9 
-    c.getIndices() returns a vector containing: 
-      0  4  0 1 1   2  0 3    0 4 2  3    0 4 
-    c.getVectorStarts() returns a vector containing: 
-      0 2 4 6 8 10 11 12 14 
-    c.getNumElements() returns 14. 
-    c.getMajorDim() returns 8. 
-  @endverbatim
-
-  Compiling this class with CLP_NO_VECTOR defined will excise all methods
-  which use CoinPackedVectorBase, CoinPackedVector, or CoinShallowPackedVector
-  as parameters or return types.
-
-  Compiling this class with COIN_FAST_CODE defined removes index range checks.
-*/
-class CoinPackedMatrix  {
-   friend void CoinPackedMatrixUnitTest();
-
-public:
-
-
-  //---------------------------------------------------------------------------
-  /**@name Query members */
-  //@{
-    /** Return the current setting of the extra gap. */
-    inline double getExtraGap() const { return extraGap_; }
-    /** Return the current setting of the extra major. */
-    inline double getExtraMajor() const { return extraMajor_; }
-
-    /** Reserve sufficient space for appending major-ordered vectors. 
-	If create is true, empty columns are created (for column generation) */
-    void reserve(const int newMaxMajorDim, const CoinBigIndex newMaxSize,
-		 bool create=false);
-    /** Clear the data, but do not free any arrays */
-    void clear();
-
-    /** Whether the packed matrix is column major ordered or not. */
-    inline bool isColOrdered() const { return colOrdered_; }
-
-    /** Whether the packed matrix has gaps or not. */
-    inline bool hasGaps() const { return (size_<start_[majorDim_]) ; } 
-
-    /** Number of entries in the packed matrix. */
-    inline CoinBigIndex getNumElements() const { return size_; }
-
-    /** Number of columns. */
-    inline int getNumCols() const
-    { return colOrdered_ ? majorDim_ : minorDim_; }
-
-    /** Number of rows. */
-    inline int getNumRows() const
-    { return colOrdered_ ? minorDim_ : majorDim_; }
-
-    /*! \brief A vector containing the elements in the packed matrix.
-    
-	Returns #elements_. Note that there might be gaps in this vector,
-	entries that do not belong to any major-dimension vector. To get
-	the actual elements one should look at this vector together with
-	vectorStarts (#start_) and vectorLengths (#length_).
-    */
-    inline const double * getElements() const { return element_; }
-
-    /*! \brief A vector containing the minor indices of the elements in
-    	       the packed matrix.
-
-	Returns #index_. Note that there might be gaps in this list,
-	entries that do not belong to any major-dimension vector. To get
-	the actual elements one should look at this vector together with
-	vectorStarts (#start_) and vectorLengths (#length_).
-    */
-    inline const int * getIndices() const { return index_; }
-
-    /*! \brief The size of the <code>vectorStarts</code> array
-
-	See #start_.
-    */
-    inline int getSizeVectorStarts() const
-    { return ((majorDim_ > 0)?(majorDim_+1):(0)) ; }
-
-    /*! \brief The size of the <code>vectorLengths</code> array
-    
-        See #length_.
-    */
-    inline int getSizeVectorLengths() const { return majorDim_; }
-
-    /*! \brief The positions where the major-dimension vectors start in
-    	       elements and indices.
-
-	See #start_.
-    */
-    inline const CoinBigIndex * getVectorStarts() const { return start_; }
-
-    /*! \brief The lengths of the major-dimension vectors.
-    
-        See #length_.
-    */
-    inline const int * getVectorLengths() const { return length_; }
-
-    /** The position of the first element in the i'th major-dimension vector.
-     */
-    CoinBigIndex getVectorFirst(const int i) const {
-#ifndef COIN_FAST_CODE
-      if (i < 0 || i >= majorDim_)
-	throw CoinError("bad index", "vectorFirst", "CoinPackedMatrix");
-#endif
-      return start_[i];
-    }
-    /** The position of the last element (well, one entry <em>past</em> the
-        last) in the i'th major-dimension vector. */
-    CoinBigIndex getVectorLast(const int i) const {
-#ifndef COIN_FAST_CODE
-      if (i < 0 || i >= majorDim_)
-	throw CoinError("bad index", "vectorLast", "CoinPackedMatrix");
-#endif
-      return start_[i] + length_[i];
-    }
-    /** The length of i'th vector. */
-    inline int getVectorSize(const int i) const {
-#ifndef COIN_FAST_CODE
-      if (i < 0 || i >= majorDim_)
-	throw CoinError("bad index", "vectorSize", "CoinPackedMatrix");
-#endif
-      return length_[i];
-    }
-#ifndef CLP_NO_VECTOR  
-    /** Return the i'th vector in matrix. */
-    const CoinShallowPackedVector getVector(int i) const {
-#ifndef COIN_FAST_CODE
-      if (i < 0 || i >= majorDim_)
-	throw CoinError("bad index", "vector", "CoinPackedMatrix");
-#endif
-      return CoinShallowPackedVector(length_[i],
-  				    index_ + start_[i],
-  				    element_ + start_[i],
-  				    false);
-    }
-#endif
-    /** Returns an array containing major indices.  The array is
-	  getNumElements long and if getVectorStarts() is 0,2,5 then
-	  the array would start 0,0,1,1,1,2...
-	  This method is provided to go back from a packed format
-	  to a triple format.  It returns NULL if there are gaps in
-	  matrix so user should use removeGaps() if there are any gaps.
-	  It does this as this array has to match getElements() and 
-	  getIndices() and because it makes no sense otherwise.
-	  The returned array is allocated with <code>new int[]</code>,
-	  free it with  <code>delete[]</code>. */
-    int * getMajorIndices() const;
-  //@}
-
-  //---------------------------------------------------------------------------
-  /**@name Modifying members */
-  //@{
-    /*! \brief Set the dimensions of the matrix.
-    
-      The method name is deceptive; the effect is to append empty columns
-      and/or rows to the matrix to reach the specified dimensions.
-      A negative number for either dimension means that that dimension
-      doesn't change. An exception will be thrown if the specified dimensions
-      are smaller than the current dimensions.
-    */
-    void setDimensions(int numrows, int numcols);
-   
-    /** Set the extra gap to be allocated to the specified value. */
-    void setExtraGap(const double newGap);
-    /** Set the extra major to be allocated to the specified value. */
-    void setExtraMajor(const double newMajor);
-#ifndef CLP_NO_VECTOR
-    /*! Append a column to the end of the matrix.
-    
-       When compiled with COIN_DEBUG defined this method throws an exception
-       if the column vector specifies a nonexistent row index.  Otherwise the
-       method assumes that every index fits into the matrix.
-    */
-    void appendCol(const CoinPackedVectorBase& vec);
-#endif
-    /*! Append a column to the end of the matrix.
-    
-       When compiled with COIN_DEBUG defined this method throws an exception
-       if the column vector specifies a nonexistent row index.  Otherwise the
-       method assumes that every index fits into the matrix.
-    */
-    void appendCol(const int vecsize,
-  		   const int *vecind, const double *vecelem);
-#ifndef CLP_NO_VECTOR
-    /*! Append a set of columns to the end of the matrix.
-
-       When compiled with COIN_DEBUG defined this method throws an exception
-       if any of the column vectors specify a nonexistent row index. Otherwise
-       the method assumes that every index fits into the matrix.
-    */
-    void appendCols(const int numcols,
-		    const CoinPackedVectorBase * const * cols);
-#endif
-    /*! Append a set of columns to the end of the matrix.
-    
-      Returns the number of errors (nonexistent or duplicate row index).
-      No error checking is performed if \p numberRows < 0.
-    */
-    int appendCols(const int numcols,
-		    const CoinBigIndex * columnStarts, const int * row,
-                   const double * element, int numberRows=-1);
-#ifndef CLP_NO_VECTOR
-    /*! Append a row to the end of the matrix.
-  
-       When compiled with COIN_DEBUG defined this method throws an exception
-       if the row vector specifies a nonexistent column index.  Otherwise the
-       method assumes that every index fits into the matrix.
-    */
-    void appendRow(const CoinPackedVectorBase& vec);
-#endif
-    /*! Append a row to the end of the matrix.
-
-       When compiled with COIN_DEBUG defined this method throws an exception
-       if the row vector specifies a nonexistent column index.  Otherwise the
-       method assumes that every index fits into the matrix.
-    */
-    void appendRow(const int vecsize,
-  		  const int *vecind, const double *vecelem);
-#ifndef CLP_NO_VECTOR
-    /*! Append a set of rows to the end of the matrix.
-    
-       When compiled with COIN_DEBUG defined this method throws an exception
-       if any of the row vectors specify a nonexistent column index. Otherwise
-       the method assumes that every index fits into the matrix.
-    */
-    void appendRows(const int numrows,
-		    const CoinPackedVectorBase * const * rows);
-#endif
-    /*! Append a set of rows to the end of the matrix.
-    
-      Returns the number of errors (nonexistent or duplicate column index).
-      No error checking is performed if \p numberColumns < 0.
-    */
-    int appendRows(const int numrows,
-		    const CoinBigIndex * rowStarts, const int * column,
-                   const double * element, int numberColumns=-1);
-  
-    /** Append the argument to the "right" of the current matrix. Imagine this
-        as adding new columns (don't worry about how the matrices are ordered,
-        that is taken care of). An exception is thrown if the number of rows
-        is different in the matrices. */
-    void rightAppendPackedMatrix(const CoinPackedMatrix& matrix);
-    /** Append the argument to the "bottom" of the current matrix. Imagine this
-        as adding new rows (don't worry about how the matrices are ordered,
-        that is taken care of). An exception is thrown if the number of columns
-        is different in the matrices. */
-    void bottomAppendPackedMatrix(const CoinPackedMatrix& matrix);
-  
-    /** Delete the columns whose indices are listed in <code>indDel</code>. */
-    void deleteCols(const int numDel, const int * indDel);
-    /** Delete the rows whose indices are listed in <code>indDel</code>. */
-    void deleteRows(const int numDel, const int * indDel);
-
-    /** Replace the elements of a vector.  The indices remain the same.
-	At most the number specified will be replaced.
-        The index is between 0 and major dimension of matrix */
-    void replaceVector(const int index,
-		       const int numReplace, const double * newElements);
-    /** Modify one element of packed matrix.  An element may be added.
-        This works for either ordering
-	If the new element is zero it will be deleted unless
-	keepZero true */
-    void modifyCoefficient(int row, int column, double newElement,
-			   bool keepZero=false);
-    /** Return one element of packed matrix.
-        This works for either ordering
-	If it is not present will return 0.0 */
-    double getCoefficient(int row, int column) const;
-
-    /** Eliminate all elements in matrix whose 
-	absolute value is less than threshold.
-	The column starts are not affected.  Returns number of elements
-	eliminated.  Elements eliminated are at end of each vector
-    */
-    int compress(double threshold);
-    /** Eliminate all duplicate AND small elements in matrix 
-	The column starts are not affected.  Returns number of elements
-	eliminated.  
-    */
-    int eliminateDuplicates(double threshold);
-    /** Sort all columns so indices are increasing.in each column */
-    void orderMatrix();
-    /** Really clean up matrix.
-	a) eliminate all duplicate AND small elements in matrix 
-	b) remove all gaps and set extraGap_ and extraMajor_ to 0.0
-	c) reallocate arrays and make max lengths equal to lengths
-	d) orders elements
-	returns number of elements eliminated
-    */
-    int cleanMatrix(double threshold=1.0e-20);
-  //@}
-
-  //---------------------------------------------------------------------------
-  /**@name Methods that reorganize the whole matrix */
-  //@{
-    /** Remove the gaps from the matrix if there were any
-	Can also remove small elements fabs() <= removeValue*/
-    void removeGaps(double removeValue=-1.0);
- 
-    /** Extract a submatrix from matrix. Those major-dimension vectors of
-	the matrix comprise the submatrix whose indices are given in the
-	arguments. Does not allow duplicates. */
-    void submatrixOf(const CoinPackedMatrix& matrix,
-		     const int numMajor, const int * indMajor);
-    /** Extract a submatrix from matrix. Those major-dimension vectors of
-	the matrix comprise the submatrix whose indices are given in the
-	arguments. Allows duplicates and keeps order. */
-    void submatrixOfWithDuplicates(const CoinPackedMatrix& matrix,
-		     const int numMajor, const int * indMajor);
-#if 0
-    /** Extract a submatrix from matrix. Those major/minor-dimension vectors of
-	the matrix comprise the submatrix whose indices are given in the
-	arguments. */
-    void submatrixOf(const CoinPackedMatrix& matrix,
-		     const int numMajor, const int * indMajor,
-		     const int numMinor, const int * indMinor);
-#endif
-
-    /** Copy method. This method makes an exact replica of the argument,
-        including the extra space parameters. */
-    void copyOf(const CoinPackedMatrix& rhs);
-    /** Copy the arguments to the matrix. If <code>len</code> is a NULL pointer
-        then the matrix is assumed to have no gaps in it and <code>len</code>
-        will be created accordingly. */
-    void copyOf(const bool colordered,
- 	       const int minor, const int major, const CoinBigIndex numels,
- 	       const double * elem, const int * ind,
- 	       const CoinBigIndex * start, const int * len,
- 	       const double extraMajor=0.0, const double extraGap=0.0);
-    /** Copy method. This method makes an exact replica of the argument,
-        including the extra space parameters. 
-	If there is room it will re-use arrays */
-    void copyReuseArrays(const CoinPackedMatrix& rhs);
-
-    /*! \brief Make a reverse-ordered copy.
-    
-      This method makes an exact replica of the argument with the major
-      vector orientation changed from row (column) to column (row).
-      The extra space parameters are also copied and reversed.
-      (Cf. #reverseOrdering, which does the same thing in place.)
-    */
-    void reverseOrderedCopyOf(const CoinPackedMatrix& rhs);
-
-    /** Assign the arguments to the matrix. If <code>len</code> is a NULL
-	pointer then the matrix is assumed to have no gaps in it and
-	<code>len</code> will be created accordingly. <br>
-        <strong>NOTE 1</strong>: After this method returns the pointers
-        passed to the method will be NULL pointers! <br>
-        <strong>NOTE 2</strong>: When the matrix is eventually destructed the
-        arrays will be deleted by <code>delete[]</code>. Hence one should use
-        this method ONLY if all array swere allocated by <code>new[]</code>! */
-    void assignMatrix(const bool colordered,
- 		     const int minor, const int major, 
-		      const CoinBigIndex numels,
- 		     double *& elem, int *& ind,
- 		     CoinBigIndex *& start, int *& len,
- 		     const int maxmajor = -1, const CoinBigIndex maxsize = -1);
- 
- 
- 
-    /** Assignment operator. This copies out the data, but uses the current
-        matrix's extra space parameters. */
-    CoinPackedMatrix & operator=(const CoinPackedMatrix& rhs);
- 
-    /*! \brief Reverse the ordering of the packed matrix.
-
-      Change the major vector orientation of the matrix data structures from
-      row (column) to column (row). (Cf. #reverseOrderedCopyOf, which does
-      the same thing but produces a new matrix.)
-    */
-    void reverseOrdering();
-
-    /*! \brief Transpose the matrix.
-
-        \note
-	If you start with a column-ordered matrix and invoke transpose, you
-	will have a row-ordered transposed matrix. To change the major vector
-	orientation (e.g., to transform a column-ordered matrix to a
-	column-ordered transposed matrix), invoke transpose() followed by
-	#reverseOrdering().
-    */
-    void transpose();
- 
-    /*! \brief Swap the content of two packed matrices. */
-    void swap(CoinPackedMatrix& matrix);
-   
-  //@}
-
-  //---------------------------------------------------------------------------
-  /**@name Matrix times vector methods */
-  //@{
-    /** Return <code>A * x</code> in <code>y</code>.
-        @pre <code>x</code> must be of size <code>numColumns()</code>
-        @pre <code>y</code> must be of size <code>numRows()</code> */
-    void times(const double * x, double * y) const;
-#ifndef CLP_NO_VECTOR
-    /** Return <code>A * x</code> in <code>y</code>. Same as the previous
-        method, just <code>x</code> is given in the form of a packed vector. */
-    void times(const CoinPackedVectorBase& x, double * y) const;
-#endif
-    /** Return <code>x * A</code> in <code>y</code>.
-        @pre <code>x</code> must be of size <code>numRows()</code>
-        @pre <code>y</code> must be of size <code>numColumns()</code> */
-    void transposeTimes(const double * x, double * y) const;
-#ifndef CLP_NO_VECTOR
-    /** Return <code>x * A</code> in <code>y</code>. Same as the previous
-        method, just <code>x</code> is given in the form of a packed vector. */
-    void transposeTimes(const CoinPackedVectorBase& x, double * y) const;
-#endif
-  //@}
-
-  //---------------------------------------------------------------------------
-  /**@name Helper functions used internally, but maybe useful externally.
-
-     These methods do not worry about testing whether the packed matrix is
-     row or column major ordered; they operate under the assumption that the
-     correct version is invoked. In fact, a number of other methods simply
-     just call one of these after testing the ordering of the matrix. */
-  //@{
-
-    //-------------------------------------------------------------------------
-    /**@name Queries */
-    //@{
-      /** Count the number of entries in every minor-dimension vector and
-	  return an array containing these lengths. The returned array is
-	  allocated with <code>new int[]</code>, free it with
-	  <code>delete[]</code>. */
-      int * countOrthoLength() const;
-      /** Count the number of entries in every minor-dimension vector and
-	  fill in an array containing these lengths.  */
-      void countOrthoLength(int * counts) const;
-      /** Major dimension. For row ordered matrix this would be the number of
-          rows. */
-      inline int getMajorDim() const { return majorDim_; }
-      /** Set major dimension. For row ordered matrix this would be the number of
-          rows. Use with great care.*/
-      inline void setMajorDim(int value) { majorDim_ = value; }
-      /** Minor dimension. For row ordered matrix this would be the number of
-	  columns. */
-      inline int getMinorDim() const { return minorDim_; }
-      /** Set minor dimension. For row ordered matrix this would be the number of
-          columns. Use with great care.*/
-      inline void setMinorDim(int value) { minorDim_ = value; }
-      /** Current maximum for major dimension. For row ordered matrix this many
-          rows can be added without reallocating the vector related to the
-	  major dimension (<code>start_</code> and <code>length_</code>). */
-      inline int getMaxMajorDim() const { return maxMajorDim_; }
-
-      /** Dump the matrix on stdout. When in dire straits this method can
-	  help. */
-      void dumpMatrix(const char* fname = NULL) const;
-
-      /// Print a single matrix element.
-      void printMatrixElement(const int row_val, const int col_val) const;
-    //@}
-
-    //-------------------------------------------------------------------------
-    /*! @name Append vectors
-
-       \details
-       When compiled with COIN_DEBUG defined these methods throw an exception
-       if the major (minor) vector contains an index that's invalid for the
-       minor (major) dimension. Otherwise the methods assume that every index
-       fits into the matrix.
-    */
-    //@{
-#ifndef CLP_NO_VECTOR
-      /** Append a major-dimension vector to the end of the matrix. */
-      void appendMajorVector(const CoinPackedVectorBase& vec);
-#endif
-      /** Append a major-dimension vector to the end of the matrix. */
-      void appendMajorVector(const int vecsize, const int *vecind,
-			     const double *vecelem);
-#ifndef CLP_NO_VECTOR
-      /** Append several major-dimensonvectors to the end of the matrix */
-      void appendMajorVectors(const int numvecs,
-			      const CoinPackedVectorBase * const * vecs);
-
-      /** Append a minor-dimension vector to the end of the matrix. */
-      void appendMinorVector(const CoinPackedVectorBase& vec);
-#endif
-      /** Append a minor-dimension vector to the end of the matrix. */
-      void appendMinorVector(const int vecsize, const int *vecind,
-			     const double *vecelem);
-#ifndef CLP_NO_VECTOR
-      /** Append several minor-dimension vectors to the end of the matrix */
-      void appendMinorVectors(const int numvecs,
-			      const CoinPackedVectorBase * const * vecs);
-#endif
-    /*! \brief Append a set of rows (columns) to the end of a column (row)
-    	       ordered matrix.
-    
-      This case is when we know there are no gaps and majorDim_ will not
-      change.
-
-      \todo
-      This method really belongs in the group of protected methods with
-      #appendMinor; there are no safeties here even with COIN_DEBUG.
-      Apparently this method was needed in ClpPackedMatrix and giving it
-      proper visibility was too much trouble. Should be moved.
-    */
-    void appendMinorFast(const int number,
-		    const CoinBigIndex * starts, const int * index,
-                    const double * element);
-    //@}
-
-    //-------------------------------------------------------------------------
-    /*! \name Append matrices
-
-      \details
-      We'll document these methods assuming that the current matrix is
-      column major ordered (Hence in the <code>...SameOrdered()</code>
-      methods the argument is column ordered, in the
-      <code>OrthoOrdered()</code> methods the argument is row ordered.)
-    */
-    //@{
-      /** Append the columns of the argument to the right end of this matrix.
-	  @pre <code>minorDim_ == matrix.minorDim_</code> <br>
-	  This method throws an exception if the minor dimensions are not the
-	  same. */
-      void majorAppendSameOrdered(const CoinPackedMatrix& matrix);
-      /** Append the columns of the argument to the bottom end of this matrix.
-	  @pre <code>majorDim_ == matrix.majorDim_</code> <br>
-	  This method throws an exception if the major dimensions are not the
-	  same. */
-      void minorAppendSameOrdered(const CoinPackedMatrix& matrix);
-      /** Append the rows of the argument to the right end of this matrix.
-	  @pre <code>minorDim_ == matrix.majorDim_</code> <br>
-	  This method throws an exception if the minor dimension of the
-	  current matrix is not the same as the major dimension of the
-	  argument matrix. */
-      void majorAppendOrthoOrdered(const CoinPackedMatrix& matrix);
-      /** Append the rows of the argument to the bottom end of this matrix.
-	  @pre <code>majorDim_ == matrix.minorDim_</code> <br>
-	  This method throws an exception if the major dimension of the
-	  current matrix is not the same as the minor dimension of the
-	  argument matrix. */
-      void minorAppendOrthoOrdered(const CoinPackedMatrix& matrix);
-      //@}
-
-      //-----------------------------------------------------------------------
-      /**@name Delete vectors */
-      //@{
-      /** Delete the major-dimension vectors whose indices are listed in
-	  <code>indDel</code>. */
-      void deleteMajorVectors(const int numDel, const int * indDel);
-      /** Delete the minor-dimension vectors whose indices are listed in
-	  <code>indDel</code>. */
-      void deleteMinorVectors(const int numDel, const int * indDel);
-      //@}
-
-      //-----------------------------------------------------------------------
-      /**@name Various dot products. */
-      //@{
-      /** Return <code>A * x</code> (multiplied from the "right" direction) in
-	  <code>y</code>.
-	  @pre <code>x</code> must be of size <code>majorDim()</code>
-	  @pre <code>y</code> must be of size <code>minorDim()</code> */
-      void timesMajor(const double * x, double * y) const;
-#ifndef CLP_NO_VECTOR
-      /** Return <code>A * x</code> (multiplied from the "right" direction) in
-	  <code>y</code>. Same as the previous method, just <code>x</code> is
-	  given in the form of a packed vector. */
-      void timesMajor(const CoinPackedVectorBase& x, double * y) const;
-#endif
-      /** Return <code>A * x</code> (multiplied from the "right" direction) in
-	  <code>y</code>.
-	  @pre <code>x</code> must be of size <code>minorDim()</code>
-	  @pre <code>y</code> must be of size <code>majorDim()</code> */
-      void timesMinor(const double * x, double * y) const;
-#ifndef CLP_NO_VECTOR
-      /** Return <code>A * x</code> (multiplied from the "right" direction) in
-	  <code>y</code>. Same as the previous method, just <code>x</code> is
-	  given in the form of a packed vector. */
-      void timesMinor(const CoinPackedVectorBase& x, double * y) const;
-#endif
-      //@}
-   //@}
-
-   //--------------------------------------------------------------------------
-   /**@name Logical Operations. */
-   //@{
-#ifndef CLP_NO_VECTOR
-   /*! \brief Test for equivalence.
-
-       Two matrices are equivalent if they are both row- or column-ordered,
-       they have the same dimensions, and each (major) vector is equivalent.
-       The operator used to test for equality can be specified using the
-       \p FloatEqual template parameter.
-   */
-   template <class FloatEqual> bool 
-   isEquivalent(const CoinPackedMatrix& rhs, const FloatEqual& eq) const
-   {
-      // Both must be column order or both row ordered and must be of same size
-      if ((isColOrdered() ^ rhs.isColOrdered()) ||
-	  (getNumCols() != rhs.getNumCols()) ||
-	  (getNumRows() != rhs.getNumRows()) ||
-	  (getNumElements() != rhs.getNumElements()))
-	 return false;
-     
-      for (int i=getMajorDim()-1; i >= 0; --i) {
-        CoinShallowPackedVector pv = getVector(i);
-        CoinShallowPackedVector rhsPv = rhs.getVector(i);
-        if ( !pv.isEquivalent(rhsPv,eq) )
-          return false;
-      }
-      return true;
-   }
-
-  /*! \brief Test for equivalence and report differences
-
-    Equivalence is defined as for #isEquivalent. In addition, this method will
-    print differences to std::cerr. Intended for use in unit tests and
-    for debugging.
-  */
-  bool isEquivalent2(const CoinPackedMatrix& rhs) const;
-#else
-   /*! \brief Test for equivalence.
-
-       Two matrices are equivalent if they are both row- or column-ordered,
-       they have the same dimensions, and each (major) vector is equivalent.
-       This method is optimised for speed. CoinPackedVector#isEquivalent is
-       replaced with more efficient code for repeated comparison of
-       equal-length vectors. The CoinRelFltEq operator is used. 
-   */
-  bool isEquivalent(const CoinPackedMatrix& rhs, const CoinRelFltEq & eq) const;
-#endif
-   /*! \brief Test for equivalence.
-   
-     The test for element equality is the default CoinRelFltEq operator.
-   */
-   bool isEquivalent(const CoinPackedMatrix& rhs) const;
-   //@}
-
-   //--------------------------------------------------------------------------
-   /*! \name Non-const methods
-
-     These are to be used with great care when doing column generation, etc.
-   */
-   //@{
-    /** A vector containing the elements in the packed matrix. Note that there
-	might be gaps in this list, entries that do not belong to any
-	major-dimension vector. To get the actual elements one should look at
-	this vector together with #start_ and #length_. */
-    inline double * getMutableElements() const { return element_; }
-    /** A vector containing the minor indices of the elements in the packed
-        matrix. Note that there might be gaps in this list, entries that do not
-        belong to any major-dimension vector. To get the actual elements one
-        should look at this vector together with #start_ and
-        #length_. */
-    inline int * getMutableIndices() const { return index_; }
-
-    /** The positions where the major-dimension vectors start in #element_ and
-        #index_. */
-    inline CoinBigIndex * getMutableVectorStarts() const { return start_; }
-    /** The lengths of the major-dimension vectors. */
-    inline int * getMutableVectorLengths() const { return length_; }
-    /// Change the size of the bulk store after modifying - be careful
-    inline void setNumElements(CoinBigIndex value)
-    { size_ = value;}
-    /*! NULLify element array
-    
-      Used when space is very tight. Does not free the space!
-    */
-    inline void nullElementArray() {element_=NULL;}
-
-    /*! NULLify start array
-    
-      Used when space is very tight. Does not free the space!
-    */
-    inline void nullStartArray() {start_=NULL;}
-
-    /*! NULLify length array
-    
-      Used when space is very tight. Does not free the space!
-    */
-    inline void nullLengthArray() {length_=NULL;}
-
-    /*! NULLify index array
-    
-      Used when space is very tight. Does not free the space!
-    */
-    inline void nullIndexArray() {index_=NULL;}
-   //@}
-
-   //--------------------------------------------------------------------------
-   /*! \name Constructors and destructors */
-   //@{
-   /// Default Constructor creates an empty column ordered packed matrix
-   CoinPackedMatrix();
-
-   /// A constructor where the ordering and the gaps are specified
-   CoinPackedMatrix(const bool colordered,
-		   const double extraMajor, const double extraGap);
-
-   CoinPackedMatrix(const bool colordered,
-		   const int minor, const int major, const CoinBigIndex numels,
-		   const double * elem, const int * ind,
-		   const CoinBigIndex * start, const int * len,
-		   const double extraMajor, const double extraGap);
-
-   CoinPackedMatrix(const bool colordered,
-		   const int minor, const int major, const CoinBigIndex numels,
-		   const double * elem, const int * ind,
-		   const CoinBigIndex * start, const int * len);
-
-   /** Create packed matrix from triples.
-       If colordered is true then the created matrix will be column ordered.
-       Duplicate matrix elements are allowed. The created matrix will have 
-       the sum of the duplicates. <br>
-       For example if: <br>
-         rowIndices[0]=2; colIndices[0]=5; elements[0]=2.0 <br>
-         rowIndices[1]=2; colIndices[1]=5; elements[1]=0.5 <br>
-       then the created matrix will contain a value of 2.5 in row 2 and column 5.<br>
-       The matrix is created without gaps.
-   */
-   CoinPackedMatrix(const bool colordered,
-     const int * rowIndices, 
-     const int * colIndices, 
-     const double * elements, 
-     CoinBigIndex numels ); 
-
-   /// Copy constructor 
-   CoinPackedMatrix(const CoinPackedMatrix& m);
-
-  /*! \brief Copy constructor with fine tuning
-  
-    This constructor allows for the specification of an exact amount of extra
-    space and/or reverse ordering.
-
-    \p extraForMajor is the exact number of spare major vector slots after
-    any possible reverse ordering. If \p extraForMajor < 0, all gaps and small
-    elements will be removed from the copy, otherwise gaps and small elements
-    are preserved.
-
-    \p extraElements is the exact number of spare element entries.
-
-    The usual multipliers, #extraMajor_ and #extraGap_, are set to zero.
-  */
-  CoinPackedMatrix(const CoinPackedMatrix &m,
-  		   int extraForMajor, int extraElements,
-		   bool reverseOrdering = false) ;
-
-  /** Subset constructor (without gaps).  Duplicates are allowed
-      and order is as given */
-  CoinPackedMatrix (const CoinPackedMatrix & wholeModel,
-		    int numberRows, const int * whichRows,
-		    int numberColumns, const int * whichColumns);
-
-   /// Destructor 
-   virtual ~CoinPackedMatrix();    
-   //@}
-
-  /*! \name Debug Utilities */
-  //@{
-    /*! \brief Scan the matrix for anomalies.
-
-	Returns the number of anomalies. Scans the structure for gaps,
-	obviously bogus indices and coefficients, and inconsistencies. Gaps
-	are not an error unless #hasGaps() says the matrix should be
-	gap-free. Zeroes are not an error unless \p zeroesAreError is set to
-	true.
-	
-	Values for verbosity are:
-	- 0: No messages, just the return value
-	- 1: Messages about errors
-	- 2: If there are no errors, a message indicating the matrix was
-	     checked is printed (positive confirmation).
-	- 3: Adds a bit more information about the matrix.
-	- 4: Prints warnings about zeroes even if they're not considered
-	     errors.
-
-	Obviously bogus coefficients are coefficients that are NaN or have
-	absolute value greater than 1e50. Zeros have absolute value less
-	than 1e-50.
-      */
-    int verifyMtx(int verbosity = 1, bool zeroesAreError = false) const ;
-  //@}
-
-  //--------------------------------------------------------------------------
-protected:
-   void gutsOfDestructor();
-   void gutsOfCopyOf(const bool colordered,
-		     const int minor, const int major, const CoinBigIndex numels,
-		     const double * elem, const int * ind,
-		     const CoinBigIndex * start, const int * len,
-		     const double extraMajor=0.0, const double extraGap=0.0);
-   /// When no gaps we can do faster
-   void gutsOfCopyOfNoGaps(const bool colordered,
-		     const int minor, const int major,
-		     const double * elem, const int * ind,
-                           const CoinBigIndex * start);
-   void gutsOfOpEqual(const bool colordered,
-		      const int minor, const int major, const CoinBigIndex numels,
-		      const double * elem, const int * ind,
-		      const CoinBigIndex * start, const int * len);
-   void resizeForAddingMajorVectors(const int numVec, const int * lengthVec);
-   void resizeForAddingMinorVectors(const int * addedEntries);
-
-    /*! \brief Append a set of rows (columns) to the end of a row (colum)
-    	       ordered matrix.
-	
-      If \p numberOther > 0 the method will check if any of the new rows
-      (columns) contain duplicate indices or invalid indices and return the
-      number of errors. A valid minor index must satisfy
-      \code 0 <= k < numberOther \endcode
-      If \p numberOther < 0 no checking is performed.
-    */
-    int appendMajor(const int number,
-		    const CoinBigIndex * starts, const int * index,
-                    const double * element, int numberOther=-1);
-    /*! \brief Append a set of rows (columns) to the end of a column (row)
-    	       ordered matrix.
-    
-      If \p numberOther > 0 the method will check if any of the new rows
-      (columns) contain duplicate indices or indices outside the current
-      range for the major dimension and return the number of violations.
-      If \p numberOther <= 0 the major dimension will be expanded as
-      necessary and there are no checks for duplicate indices.
-    */
-    int appendMinor(const int number,
-		    const CoinBigIndex * starts, const int * index,
-                    const double * element, int numberOther=-1);
-
-private:
-   inline CoinBigIndex getLastStart() const {
-      return majorDim_ == 0 ? 0 : start_[majorDim_];
-   }
-
-   //--------------------------------------------------------------------------
-protected:
-   /**@name Data members
-      The data members are protected to allow access for derived classes. */
-   //@{
-   /** A flag indicating whether the matrix is column or row major ordered. */
-   bool     colOrdered_;
-   /** This much times more space should be allocated for each major-dimension
-       vector (with respect to the number of entries in the vector) when the
-       matrix is resized. The purpose of these gaps is to allow fast insertion
-       of new minor-dimension vectors. */
-   double   extraGap_;
-   /** his much times more space should be allocated for major-dimension
-       vectors when the matrix is resized. The purpose of these gaps is to
-       allow fast addition of new major-dimension vectors. */
-   double   extraMajor_;
-
-   /** List of nonzero element values. The entries in the gaps between
-       major-dimension vectors are undefined. */
-   double  *element_;
-   /** List of nonzero element minor-dimension indices. The entries in the gaps
-       between major-dimension vectors are undefined. */
-   int     *index_;
-   /** Starting positions of major-dimension vectors. */
-   CoinBigIndex     *start_;
-   /** Lengths of major-dimension vectors. */
-   int     *length_;
-
-   /// number of vectors in matrix
-   int majorDim_;
-   /// size of other dimension
-   int minorDim_;
-   /// the number of nonzero entries
-   CoinBigIndex size_;
-
-   /// max space allocated for major-dimension
-   int maxMajorDim_;
-   /// max space allocated for entries
-   CoinBigIndex maxSize_;
-   //@}
-};
-
-//#############################################################################
-/*! \brief Test the methods in the CoinPackedMatrix class.
-
-    The only reason for it not to be a member method is that this way
-    it doesn't have to be compiled into the library. And that's a gain,
-    because the library should be compiled with optimization on, but this
-    method should be compiled with debugging.
-*/
-void
-CoinPackedMatrixUnitTest();
-
-#endif