Added linux shared libraries and header files for int and ecos functions

1 files changed, 1164 insertions, 0 deletions

diff --git a/thirdparty/linux/include/coin1/CoinIndexedVector.hpp b/thirdparty/linux/include/coin1/CoinIndexedVector.hpp
new file mode 100644
index 0000000..9c386c5
--- /dev/null
+++ b/thirdparty/linux/include/coin1/CoinIndexedVector.hpp
@@ -0,0 +1,1164 @@
+/* $Id: CoinIndexedVector.hpp 1767 2015-01-05 12:36:13Z forrest $ */
+// 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 CoinIndexedVector_H
+#define CoinIndexedVector_H
+
+#if defined(_MSC_VER)
+// Turn off compiler warning about long names
+#  pragma warning(disable:4786)
+#endif
+
+#include <map>
+#include "CoinFinite.hpp"
+#ifndef CLP_NO_VECTOR
+#include "CoinPackedVectorBase.hpp"
+#endif
+#include "CoinSort.hpp"
+#include "CoinHelperFunctions.hpp"
+#include <cassert>
+
+#ifndef COIN_FLOAT
+#define COIN_INDEXED_TINY_ELEMENT 1.0e-50
+#define COIN_INDEXED_REALLY_TINY_ELEMENT 1.0e-100
+#else
+#define COIN_INDEXED_TINY_ELEMENT 1.0e-35
+#define COIN_INDEXED_REALLY_TINY_ELEMENT 1.0e-39
+#endif
+
+/** Indexed Vector
+
+This stores values unpacked but apart from that is a bit like CoinPackedVector.
+It is designed to be lightweight in normal use.
+
+It now has a "packed" mode when it is even more like CoinPackedVector
+
+Indices array has capacity_ extra chars which are zeroed and can
+be used for any purpose - but must be re-zeroed
+
+Stores vector of indices and associated element values.
+Supports sorting of indices.  
+
+Does not support negative indices.
+
+Does NOT support testing for duplicates
+
+*** getElements is no longer supported
+
+Here is a sample usage:
+@verbatim
+    const int ne = 4;
+    int inx[ne] =   {  1,   4,  0,   2 }
+    double el[ne] = { 10., 40., 1., 50. }
+
+    // Create vector and set its valuex1
+    CoinIndexedVector r(ne,inx,el);
+
+    // access as a full storage vector
+    assert( r[ 0]==1. );
+    assert( r[ 1]==10.);
+    assert( r[ 2]==50.);
+    assert( r[ 3]==0. );
+    assert( r[ 4]==40.);
+
+    // sort Elements in increasing order
+    r.sortIncrElement();
+
+    // access each index and element
+    assert( r.getIndices ()[0]== 0  );
+    assert( r.getIndices ()[1]== 1  );
+    assert( r.getIndices ()[2]== 4  );
+    assert( r.getIndices ()[3]== 2  );
+
+    // access as a full storage vector
+    assert( r[ 0]==1. );
+    assert( r[ 1]==10.);
+    assert( r[ 2]==50.);
+    assert( r[ 3]==0. );
+    assert( r[ 4]==40.);
+
+    // Tests for equality and equivalence
+    CoinIndexedVector r1;
+    r1=r;
+    assert( r==r1 );
+    assert( r.equivalent(r1) );
+    r.sortIncrElement();
+    assert( r!=r1 );
+    assert( r.equivalent(r1) );
+
+    // Add indexed vectors.
+    // Similarly for subtraction, multiplication,
+    // and division.
+    CoinIndexedVector add = r + r1;
+    assert( add[0] ==  1.+ 1. );
+    assert( add[1] == 10.+10. );
+    assert( add[2] == 50.+50. );
+    assert( add[3] ==  0.+ 0. );
+    assert( add[4] == 40.+40. );
+
+    assert( r.sum() == 10.+40.+1.+50. );
+@endverbatim
+*/
+class CoinIndexedVector {
+   friend void CoinIndexedVectorUnitTest();
+  
+public:
+   /**@name Get methods. */
+   //@{
+   /// Get the size
+   inline int getNumElements() const { return nElements_; }
+   /// Get indices of elements
+   inline const int * getIndices() const { return indices_; }
+   /// Get element values
+   // ** No longer supported virtual const double * getElements() const ;
+   /// Get indices of elements
+   inline int * getIndices() { return indices_; }
+   /** Get the vector as a dense vector. This is normal storage method.
+       The user should not not delete [] this.
+   */
+   inline double * denseVector() const { return elements_; }
+   /// For very temporary use when user needs to borrow a dense vector
+  inline void setDenseVector(double * array)
+  { elements_ = array;}
+   /// For very temporary use when user needs to borrow an index vector
+  inline void setIndexVector(int * array)
+  { indices_ = array;}
+   /** Access the i'th element of the full storage vector.
+   */
+   double & operator[](int i) const; 
+
+   //@}
+ 
+   //-------------------------------------------------------------------
+   // Set indices and elements
+   //------------------------------------------------------------------- 
+   /**@name Set methods */
+   //@{
+   /// Set the size
+   inline void setNumElements(int value) { nElements_ = value;
+   if (!nElements_) packedMode_=false;}
+   /// Reset the vector (as if were just created an empty vector).  This leaves arrays!
+   void clear();
+   /// Reset the vector (as if were just created an empty vector)
+   void empty();
+   /** Assignment operator. */
+   CoinIndexedVector & operator=(const CoinIndexedVector &);
+#ifndef CLP_NO_VECTOR
+   /** Assignment operator from a CoinPackedVectorBase. <br>
+   <strong>NOTE</strong>: This assumes no duplicates */
+   CoinIndexedVector & operator=(const CoinPackedVectorBase & rhs);
+#endif
+   /** Copy the contents of one vector into another.  If multiplier is 1
+       It is the equivalent of = but if vectors are same size does
+       not re-allocate memory just clears and copies */
+   void copy(const CoinIndexedVector & rhs, double multiplier=1.0);
+
+   /** Borrow ownership of the arguments to this vector.
+       Size is the length of the unpacked elements vector. */
+  void borrowVector(int size, int numberIndices, int* inds, double* elems);
+
+   /** Return ownership of the arguments to this vector.
+       State after is empty .
+   */
+   void returnVector();
+
+   /** Set vector numberIndices, indices, and elements.
+       NumberIndices is the length of both the indices and elements vectors.
+       The indices and elements vectors are copied into this class instance's
+       member data. Assumed to have no duplicates */
+  void setVector(int numberIndices, const int * inds, const double * elems);
+  
+   /** Set vector size, indices, and elements.
+       Size is the length of the unpacked elements vector.
+       The indices and elements vectors are copied into this class instance's
+       member data. We do not check for duplicate indices */
+   void setVector(int size, int numberIndices, const int * inds, const double * elems);
+  
+   /** Elements set to have the same scalar value */
+  void setConstant(int size, const int * inds, double elems);
+  
+   /** Indices are not specified and are taken to be 0,1,...,size-1 */
+  void setFull(int size, const double * elems);
+
+   /** Set an existing element in the indexed vector
+       The first argument is the "index" into the elements() array
+   */
+   void setElement(int index, double element);
+
+   /// Insert an element into the vector
+   void insert(int index, double element);
+   /// Insert a nonzero element into the vector
+   inline void quickInsert(int index, double element)
+               {
+		 assert (!elements_[index]);
+		 indices_[nElements_++] = index;
+		 assert (nElements_<=capacity_);
+		 elements_[index] = element;
+	       }
+   /** Insert or if exists add an element into the vector
+       Any resulting zero elements will be made tiny */
+   void add(int index, double element);
+   /** Insert or if exists add an element into the vector
+       Any resulting zero elements will be made tiny.
+       This version does no checking */
+   inline void quickAdd(int index, double element)
+               {
+		 if (elements_[index]) {
+		   element += elements_[index];
+		   if ((element > 0 ? element : -element) >= COIN_INDEXED_TINY_ELEMENT) {
+		     elements_[index] = element;
+		   } else {
+		     elements_[index] = 1.0e-100;
+		   }
+		 } else if ((element > 0 ? element : -element) >= COIN_INDEXED_TINY_ELEMENT) {
+		   indices_[nElements_++] = index;
+		   assert (nElements_<=capacity_);
+		   elements_[index] = element;
+		 }
+	       }
+   /** Insert or if exists add an element into the vector
+       Any resulting zero elements will be made tiny.
+       This knows element is nonzero
+       This version does no checking */
+   inline void quickAddNonZero(int index, double element)
+               {
+		 assert (element);
+		 if (elements_[index]) {
+		   element += elements_[index];
+		   if ((element > 0 ? element : -element) >= COIN_INDEXED_TINY_ELEMENT) {
+		     elements_[index] = element;
+		   } else {
+		     elements_[index] = COIN_DBL_MIN;
+		   }
+		 } else {
+		   indices_[nElements_++] = index;
+		   assert (nElements_<=capacity_);
+		   elements_[index] = element;
+		 }
+	       }
+   /** Makes nonzero tiny.
+       This version does no checking */
+   inline void zero(int index)
+               {
+		 if (elements_[index]) 
+		   elements_[index] = COIN_DBL_MIN;
+	       }
+   /** set all small values to zero and return number remaining
+      - < tolerance => 0.0 */
+   int clean(double tolerance);
+   /// Same but packs down
+   int cleanAndPack(double tolerance);
+   /// Same but packs down and is safe (i.e. if order is odd)
+   int cleanAndPackSafe(double tolerance);
+  /// Mark as packed
+  inline void setPacked()
+  { packedMode_ = true;}
+#ifndef NDEBUG
+   /// For debug check vector is clear i.e. no elements
+   void checkClear();
+   /// For debug check vector is clean i.e. elements match indices
+   void checkClean();
+#else
+  inline void checkClear() {};
+  inline void checkClean() {};
+#endif
+   /// Scan dense region and set up indices (returns number found)
+   int scan();
+   /** Scan dense region from start to < end and set up indices
+       returns number found
+   */
+   int scan(int start, int end);
+  /** Scan dense region and set up indices (returns number found).
+      Only ones >= tolerance */
+   int scan(double tolerance);
+   /** Scan dense region from start to < end and set up indices
+       returns number found.  Only >= tolerance
+   */
+   int scan(int start, int end, double tolerance);
+   /// These are same but pack down
+   int scanAndPack();
+   int scanAndPack(int start, int end);
+   int scanAndPack(double tolerance);
+   int scanAndPack(int start, int end, double tolerance);
+   /// Create packed array
+   void createPacked(int number, const int * indices, 
+		    const double * elements);
+   /// Create unpacked array
+   void createUnpacked(int number, const int * indices, 
+		    const double * elements);
+   /// Create unpacked singleton
+   void createOneUnpackedElement(int index, double element);
+   /// This is mainly for testing - goes from packed to indexed
+   void expand();
+#ifndef CLP_NO_VECTOR
+   /// Append a CoinPackedVector to the end
+   void append(const CoinPackedVectorBase & caboose);
+#endif
+   /// Append a CoinIndexedVector to the end (with extra space)
+   void append(const CoinIndexedVector & caboose);
+   /// Append a CoinIndexedVector to the end and modify indices
+  void append(CoinIndexedVector & other,int adjustIndex,bool zapElements=false);
+
+   /// Swap values in positions i and j of indices and elements
+   void swap(int i, int j); 
+
+   /// Throw away all entries in rows >= newSize
+   void truncate(int newSize); 
+   ///  Print out
+   void print() const;
+   //@}
+   /**@name Arithmetic operators. */
+   //@{
+   /// add <code>value</code> to every entry
+   void operator+=(double value);
+   /// subtract <code>value</code> from every entry
+   void operator-=(double value);
+   /// multiply every entry by <code>value</code>
+   void operator*=(double value);
+   /// divide every entry by <code>value</code> (** 0 vanishes)
+   void operator/=(double value);
+   //@}
+
+   /**@name Comparison operators on two indexed vectors */
+   //@{
+#ifndef CLP_NO_VECTOR
+   /** Equal. Returns true if vectors have same length and corresponding
+       element of each vector is equal. */
+   bool operator==(const CoinPackedVectorBase & rhs) const;
+   /// Not equal
+   bool operator!=(const CoinPackedVectorBase & rhs) const;
+#endif
+   /** Equal. Returns true if vectors have same length and corresponding
+       element of each vector is equal. */
+   bool operator==(const CoinIndexedVector & rhs) const;
+   /// Not equal
+   bool operator!=(const CoinIndexedVector & rhs) const;
+   /// Equal with a tolerance (returns -1 or position of inequality). 
+   int isApproximatelyEqual(const CoinIndexedVector & rhs, double tolerance=1.0e-8) const;
+   //@}
+
+   /**@name Index methods */
+   //@{
+   /// Get value of maximum index
+   int getMaxIndex() const;
+   /// Get value of minimum index
+   int getMinIndex() const;
+   //@}
+
+
+   /**@name Sorting */
+   //@{ 
+   /** Sort the indexed storage vector (increasing indices). */
+   void sort()
+   { std::sort(indices_,indices_+nElements_); }
+
+   void sortIncrIndex()
+   { std::sort(indices_,indices_+nElements_); }
+
+   void sortDecrIndex();
+  
+   void sortIncrElement();
+
+   void sortDecrElement();
+   void sortPacked();
+
+   //@}
+
+  //#############################################################################
+
+  /**@name Arithmetic operators on packed vectors.
+
+   <strong>NOTE</strong>: These methods operate on those positions where at
+   least one of the arguments has a value listed. At those positions the
+   appropriate operation is executed, Otherwise the result of the operation is
+   considered 0.<br>
+   <strong>NOTE 2</strong>: Because these methods return an object (they can't
+   return a reference, though they could return a pointer...) they are
+   <em>very</em> inefficient...
+ */
+//@{
+/// Return the sum of two indexed vectors
+CoinIndexedVector operator+(
+			   const CoinIndexedVector& op2);
+
+/// Return the difference of two indexed vectors
+CoinIndexedVector operator-(
+			   const CoinIndexedVector& op2);
+
+/// Return the element-wise product of two indexed vectors
+CoinIndexedVector operator*(
+			   const CoinIndexedVector& op2);
+
+/// Return the element-wise ratio of two indexed vectors (0.0/0.0 => 0.0) (0 vanishes)
+CoinIndexedVector operator/(
+			   const CoinIndexedVector& op2);
+/// The sum of two indexed vectors
+void operator+=(const CoinIndexedVector& op2);
+
+/// The difference of two indexed vectors
+void operator-=( const CoinIndexedVector& op2);
+
+/// The element-wise product of two indexed vectors
+void operator*=(const CoinIndexedVector& op2);
+
+/// The element-wise ratio of two indexed vectors (0.0/0.0 => 0.0) (0 vanishes)
+void operator/=(const CoinIndexedVector& op2);
+//@}
+
+   /**@name Memory usage */
+   //@{
+   /** Reserve space.
+       If one knows the eventual size of the indexed vector,
+       then it may be more efficient to reserve the space.
+   */
+   void reserve(int n);
+   /** capacity returns the size which could be accomodated without
+       having to reallocate storage.
+   */
+   inline int capacity() const { return capacity_; }
+   inline void setCapacity(int value)
+   { capacity_ = value; }
+   /// Sets packed mode
+   inline void setPackedMode(bool yesNo)
+   { packedMode_=yesNo;}
+   /// Gets packed mode
+   inline bool packedMode() const
+   { return packedMode_;}
+   //@}
+
+   /**@name Constructors and destructors */
+   //@{
+   /** Default constructor */
+   CoinIndexedVector();
+   /** Alternate Constructors - set elements to vector of doubles */
+  CoinIndexedVector(int size, const int * inds, const double * elems);
+   /** Alternate Constructors - set elements to same scalar value */
+  CoinIndexedVector(int size, const int * inds, double element);
+   /** Alternate Constructors - construct full storage with indices 0 through
+       size-1. */
+  CoinIndexedVector(int size, const double * elements);
+   /** Alternate Constructors - just size */
+  CoinIndexedVector(int size);
+   /** Copy constructor. */
+   CoinIndexedVector(const CoinIndexedVector &);
+   /** Copy constructor.2 */
+   CoinIndexedVector(const CoinIndexedVector *);
+#ifndef CLP_NO_VECTOR
+   /** Copy constructor <em>from a PackedVectorBase</em>. */
+   CoinIndexedVector(const CoinPackedVectorBase & rhs);
+#endif
+   /** Destructor */
+   ~CoinIndexedVector ();
+   //@}
+    
+private:
+   /**@name Private methods */
+   //@{  
+   /// Copy internal data
+   void gutsOfSetVector(int size,
+			const int * inds, const double * elems);
+   void gutsOfSetVector(int size, int numberIndices,
+			const int * inds, const double * elems);
+   void gutsOfSetPackedVector(int size, int numberIndices,
+			const int * inds, const double * elems);
+   ///
+   void gutsOfSetConstant(int size,
+			  const int * inds, double value);
+   //@}
+
+protected:
+   /**@name Private member data */
+   //@{
+   /// Vector indices
+   int * indices_;
+   ///Vector elements
+   double * elements_;
+   /// Size of indices and packed elements vectors
+   int nElements_;
+   /// Amount of memory allocated for indices_, and elements_.
+   int capacity_;
+   ///  Offset to get where new allocated array
+   int offset_;
+   /// If true then is operating in packed mode
+   bool packedMode_;
+   //@}
+};
+
+//#############################################################################
+/** A function that tests the methods in the CoinIndexedVector 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
+CoinIndexedVectorUnitTest();
+/** Pointer with length in bytes
+    
+    This has a pointer to an array and the number of bytes in array.
+    If number of bytes==-1 then
+    CoinConditionalNew deletes existing pointer and returns new pointer
+    of correct size (and number bytes still -1).
+    CoinConditionalDelete deletes existing pointer and NULLs it.
+    So behavior is as normal (apart from New deleting pointer which will have
+    no effect with good coding practices.
+    If number of bytes >=0 then
+    CoinConditionalNew just returns existing pointer if array big enough
+    otherwise deletes existing pointer, allocates array with spare 1%+64 bytes
+    and updates number of bytes
+    CoinConditionalDelete sets number of bytes = -size-2 and then array 
+    returns NULL
+*/
+class CoinArrayWithLength {
+  
+public:
+  /**@name Get methods. */
+  //@{
+  /// Get the size
+  inline int getSize() const 
+  { return size_; }
+  /// Get the size
+  inline int rawSize() const 
+  { return size_; }
+  /// See if persistence already on
+  inline bool switchedOn() const 
+  { return size_!=-1; }
+  /// Get the capacity (just read it)
+  inline int capacity() const 
+  { return (size_>-2) ? size_ : (-size_)-2; }
+  /// Set the capacity to >=0 if <=-2
+  inline void setCapacity() 
+  { if (size_<=-2) size_ = (-size_)-2; }
+  /// Get Array
+  inline const char * array() const 
+  { return (size_>-2) ? array_ : NULL; }
+  //@}
+  
+  /**@name Set methods */
+  //@{
+  /// Set the size
+  inline void setSize(int value) 
+  { size_ = value; }
+  /// Set the size to -1
+  inline void switchOff() 
+  { size_ = -1; }
+  /// Set the size to -2 and alignment
+  inline void switchOn(int alignment=3) 
+  { size_ = -2; alignment_=alignment;}
+  /// Does what is needed to set persistence
+  void setPersistence(int flag,int currentLength);
+  /// Zero out array
+  void clear();
+  /// Swaps memory between two members
+  void swap(CoinArrayWithLength & other);
+  /// Extend a persistent array keeping data (size in bytes)
+  void extend(int newSize);
+  //@}
+  
+  /**@name Condition methods */
+  //@{
+  /// Conditionally gets new array
+  char * conditionalNew(long sizeWanted); 
+  /// Conditionally deletes
+  void conditionalDelete();
+  //@}
+  
+  /**@name Constructors and destructors */
+  //@{
+  /** Default constructor - NULL*/
+  inline CoinArrayWithLength()
+    : array_(NULL),size_(-1),offset_(0),alignment_(0)
+  { }
+  /** Alternate Constructor - length in bytes - size_ -1 */
+  inline CoinArrayWithLength(int size)
+    : size_(-1),offset_(0),alignment_(0)
+  { array_=new char [size];}
+  /** Alternate Constructor - length in bytes 
+      mode -  0 size_ set to size
+      mode>0 size_ set to size and zeroed
+      if size<=0 just does alignment
+      If abs(mode) >2 then align on that as power of 2
+  */
+  CoinArrayWithLength(int size, int mode);
+  /** Copy constructor. */
+  CoinArrayWithLength(const CoinArrayWithLength & rhs);
+  /** Copy constructor.2 */
+  CoinArrayWithLength(const CoinArrayWithLength * rhs);
+  /** Assignment operator. */
+  CoinArrayWithLength& operator=(const CoinArrayWithLength & rhs);
+  /** Assignment with length (if -1 use internal length) */
+  void copy(const CoinArrayWithLength & rhs, int numberBytes=-1);
+  /** Assignment with length - does not copy */
+  void allocate(const CoinArrayWithLength & rhs, int numberBytes);
+  /** Destructor */
+  ~CoinArrayWithLength ();
+  /// Get array with alignment
+  void getArray(int size);
+  /// Really get rid of array with alignment
+  void reallyFreeArray();
+  /// Get enough space (if more needed then do at least needed)
+  void getCapacity(int numberBytes,int numberIfNeeded=-1);
+  //@}
+  
+protected:
+  /**@name Private member data */
+  //@{
+  /// Array
+  char * array_;
+  /// Size of array in bytes
+  CoinBigIndex size_;
+  /// Offset of array
+  int offset_;
+  /// Alignment wanted (power of 2)
+  int alignment_;
+  //@}
+};
+/// double * version
+
+class CoinDoubleArrayWithLength : public CoinArrayWithLength {
+  
+public:
+  /**@name Get methods. */
+  //@{
+  /// Get the size
+  inline int getSize() const 
+  { return size_/CoinSizeofAsInt(double); }
+  /// Get Array
+  inline double * array() const 
+  { return reinterpret_cast<double *> ((size_>-2) ? array_ : NULL); }
+  //@}
+  
+  /**@name Set methods */
+  //@{
+  /// Set the size
+  inline void setSize(int value) 
+  { size_ = value*CoinSizeofAsInt(double); }
+  //@}
+  
+  /**@name Condition methods */
+  //@{
+  /// Conditionally gets new array
+  inline double * conditionalNew(int sizeWanted)
+  { return reinterpret_cast<double *> ( CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> ((sizeWanted)*CoinSizeofAsInt(double)) : -1)); }
+  //@}
+  
+  /**@name Constructors and destructors */
+  //@{
+  /** Default constructor - NULL*/
+  inline CoinDoubleArrayWithLength()
+  { array_=NULL; size_=-1;}
+  /** Alternate Constructor - length in bytes - size_ -1 */
+  inline CoinDoubleArrayWithLength(int size)
+  { array_=new char [size*CoinSizeofAsInt(double)]; size_=-1;}
+  /** Alternate Constructor - length in bytes 
+      mode -  0 size_ set to size
+      1 size_ set to size and zeroed
+  */
+  inline CoinDoubleArrayWithLength(int size, int mode)
+    : CoinArrayWithLength(size*CoinSizeofAsInt(double),mode) {}
+  /** Copy constructor. */
+  inline CoinDoubleArrayWithLength(const CoinDoubleArrayWithLength & rhs)
+    : CoinArrayWithLength(rhs) {}
+  /** Copy constructor.2 */
+  inline CoinDoubleArrayWithLength(const CoinDoubleArrayWithLength * rhs)
+    : CoinArrayWithLength(rhs) {}
+  /** Assignment operator. */
+  inline CoinDoubleArrayWithLength& operator=(const CoinDoubleArrayWithLength & rhs)
+  { CoinArrayWithLength::operator=(rhs);  return *this;}
+  //@}
+};
+/// CoinFactorizationDouble * version
+
+class CoinFactorizationDoubleArrayWithLength : public CoinArrayWithLength {
+  
+public:
+  /**@name Get methods. */
+  //@{
+  /// Get the size
+  inline int getSize() const 
+  { return size_/CoinSizeofAsInt(CoinFactorizationDouble); }
+  /// Get Array
+  inline CoinFactorizationDouble * array() const 
+  { return reinterpret_cast<CoinFactorizationDouble *> ((size_>-2) ? array_ : NULL); }
+  //@}
+  
+  /**@name Set methods */
+  //@{
+  /// Set the size
+  inline void setSize(int value) 
+  { size_ = value*CoinSizeofAsInt(CoinFactorizationDouble); }
+  //@}
+  
+  /**@name Condition methods */
+  //@{
+  /// Conditionally gets new array
+  inline CoinFactorizationDouble * conditionalNew(int sizeWanted)
+  { return reinterpret_cast<CoinFactorizationDouble *> (CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> (( sizeWanted)*CoinSizeofAsInt(CoinFactorizationDouble)) : -1)); }
+  //@}
+  
+  /**@name Constructors and destructors */
+  //@{
+  /** Default constructor - NULL*/
+  inline CoinFactorizationDoubleArrayWithLength()
+  { array_=NULL; size_=-1;}
+  /** Alternate Constructor - length in bytes - size_ -1 */
+  inline CoinFactorizationDoubleArrayWithLength(int size)
+  { array_=new char [size*CoinSizeofAsInt(CoinFactorizationDouble)]; size_=-1;}
+  /** Alternate Constructor - length in bytes 
+      mode -  0 size_ set to size
+      1 size_ set to size and zeroed
+  */
+  inline CoinFactorizationDoubleArrayWithLength(int size, int mode)
+    : CoinArrayWithLength(size*CoinSizeofAsInt(CoinFactorizationDouble),mode) {}
+  /** Copy constructor. */
+  inline CoinFactorizationDoubleArrayWithLength(const CoinFactorizationDoubleArrayWithLength & rhs)
+    : CoinArrayWithLength(rhs) {}
+  /** Copy constructor.2 */
+  inline CoinFactorizationDoubleArrayWithLength(const CoinFactorizationDoubleArrayWithLength * rhs)
+    : CoinArrayWithLength(rhs) {}
+  /** Assignment operator. */
+  inline CoinFactorizationDoubleArrayWithLength& operator=(const CoinFactorizationDoubleArrayWithLength & rhs)
+  { CoinArrayWithLength::operator=(rhs);  return *this;}
+  //@}
+};
+/// CoinFactorizationLongDouble * version
+
+class CoinFactorizationLongDoubleArrayWithLength : public CoinArrayWithLength {
+  
+public:
+  /**@name Get methods. */
+  //@{
+  /// Get the size
+  inline int getSize() const 
+  { return size_/CoinSizeofAsInt(long double); }
+  /// Get Array
+  inline long double * array() const 
+  { return reinterpret_cast<long double *> ((size_>-2) ? array_ : NULL); }
+  //@}
+  
+  /**@name Set methods */
+  //@{
+  /// Set the size
+  inline void setSize(int value) 
+  { size_ = value*CoinSizeofAsInt(long double); }
+  //@}
+  
+  /**@name Condition methods */
+  //@{
+  /// Conditionally gets new array
+  inline long double * conditionalNew(int sizeWanted)
+  { return reinterpret_cast<long double *> (CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> (( sizeWanted)*CoinSizeofAsInt(long double)) : -1)); }
+  //@}
+  
+  /**@name Constructors and destructors */
+  //@{
+  /** Default constructor - NULL*/
+  inline CoinFactorizationLongDoubleArrayWithLength()
+  { array_=NULL; size_=-1;}
+  /** Alternate Constructor - length in bytes - size_ -1 */
+  inline CoinFactorizationLongDoubleArrayWithLength(int size)
+  { array_=new char [size*CoinSizeofAsInt(long double)]; size_=-1;}
+  /** Alternate Constructor - length in bytes 
+      mode -  0 size_ set to size
+      1 size_ set to size and zeroed
+  */
+  inline CoinFactorizationLongDoubleArrayWithLength(int size, int mode)
+    : CoinArrayWithLength(size*CoinSizeofAsInt(long double),mode) {}
+  /** Copy constructor. */
+  inline CoinFactorizationLongDoubleArrayWithLength(const CoinFactorizationLongDoubleArrayWithLength & rhs)
+    : CoinArrayWithLength(rhs) {}
+  /** Copy constructor.2 */
+  inline CoinFactorizationLongDoubleArrayWithLength(const CoinFactorizationLongDoubleArrayWithLength * rhs)
+    : CoinArrayWithLength(rhs) {}
+  /** Assignment operator. */
+  inline CoinFactorizationLongDoubleArrayWithLength& operator=(const CoinFactorizationLongDoubleArrayWithLength & rhs)
+  { CoinArrayWithLength::operator=(rhs);  return *this;}
+  //@}
+};
+/// int * version
+
+class CoinIntArrayWithLength : public CoinArrayWithLength {
+  
+public:
+  /**@name Get methods. */
+  //@{
+  /// Get the size
+  inline int getSize() const 
+  { return size_/CoinSizeofAsInt(int); }
+  /// Get Array
+  inline int * array() const 
+  { return reinterpret_cast<int *> ((size_>-2) ? array_ : NULL); }
+  //@}
+  
+  /**@name Set methods */
+  //@{
+  /// Set the size
+  inline void setSize(int value) 
+  { size_ = value*CoinSizeofAsInt(int); }
+  //@}
+  
+  /**@name Condition methods */
+  //@{
+  /// Conditionally gets new array
+  inline int * conditionalNew(int sizeWanted)
+  { return reinterpret_cast<int *> (CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> (( sizeWanted)*CoinSizeofAsInt(int)) : -1)); }
+  //@}
+  
+  /**@name Constructors and destructors */
+  //@{
+  /** Default constructor - NULL*/
+  inline CoinIntArrayWithLength()
+  { array_=NULL; size_=-1;}
+  /** Alternate Constructor - length in bytes - size_ -1 */
+  inline CoinIntArrayWithLength(int size)
+  { array_=new char [size*CoinSizeofAsInt(int)]; size_=-1;}
+  /** Alternate Constructor - length in bytes 
+      mode -  0 size_ set to size
+      1 size_ set to size and zeroed
+  */
+  inline CoinIntArrayWithLength(int size, int mode)
+    : CoinArrayWithLength(size*CoinSizeofAsInt(int),mode) {}
+  /** Copy constructor. */
+  inline CoinIntArrayWithLength(const CoinIntArrayWithLength & rhs)
+    : CoinArrayWithLength(rhs) {}
+  /** Copy constructor.2 */
+  inline CoinIntArrayWithLength(const CoinIntArrayWithLength * rhs)
+    : CoinArrayWithLength(rhs) {}
+  /** Assignment operator. */
+  inline CoinIntArrayWithLength& operator=(const CoinIntArrayWithLength & rhs)
+  { CoinArrayWithLength::operator=(rhs);  return *this;}
+  //@}
+};
+/// CoinBigIndex * version
+
+class CoinBigIndexArrayWithLength : public CoinArrayWithLength {
+  
+public:
+  /**@name Get methods. */
+  //@{
+  /// Get the size
+  inline int getSize() const 
+  { return size_/CoinSizeofAsInt(CoinBigIndex); }
+  /// Get Array
+  inline CoinBigIndex * array() const 
+  { return reinterpret_cast<CoinBigIndex *> ((size_>-2) ? array_ : NULL); }
+  //@}
+  
+  /**@name Set methods */
+  //@{
+  /// Set the size
+  inline void setSize(int value) 
+  { size_ = value*CoinSizeofAsInt(CoinBigIndex); }
+  //@}
+  
+  /**@name Condition methods */
+  //@{
+  /// Conditionally gets new array
+  inline CoinBigIndex * conditionalNew(int sizeWanted)
+  { return reinterpret_cast<CoinBigIndex *> (CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> (( sizeWanted)*CoinSizeofAsInt(CoinBigIndex)) : -1)); }
+  //@}
+  
+  /**@name Constructors and destructors */
+  //@{
+  /** Default constructor - NULL*/
+  inline CoinBigIndexArrayWithLength()
+  { array_=NULL; size_=-1;}
+  /** Alternate Constructor - length in bytes - size_ -1 */
+  inline CoinBigIndexArrayWithLength(int size)
+  { array_=new char [size*CoinSizeofAsInt(CoinBigIndex)]; size_=-1;}
+  /** Alternate Constructor - length in bytes 
+      mode -  0 size_ set to size
+      1 size_ set to size and zeroed
+  */
+  inline CoinBigIndexArrayWithLength(int size, int mode)
+    : CoinArrayWithLength(size*CoinSizeofAsInt(CoinBigIndex),mode) {}
+  /** Copy constructor. */
+  inline CoinBigIndexArrayWithLength(const CoinBigIndexArrayWithLength & rhs)
+    : CoinArrayWithLength(rhs) {}
+  /** Copy constructor.2 */
+  inline CoinBigIndexArrayWithLength(const CoinBigIndexArrayWithLength * rhs)
+    : CoinArrayWithLength(rhs) {}
+  /** Assignment operator. */
+  inline CoinBigIndexArrayWithLength& operator=(const CoinBigIndexArrayWithLength & rhs)
+  { CoinArrayWithLength::operator=(rhs);  return *this;}
+  //@}
+};
+/// unsigned int * version
+
+class CoinUnsignedIntArrayWithLength : public CoinArrayWithLength {
+  
+public:
+  /**@name Get methods. */
+  //@{
+  /// Get the size
+  inline int getSize() const 
+  { return size_/CoinSizeofAsInt(unsigned int); }
+  /// Get Array
+  inline unsigned int * array() const 
+  { return reinterpret_cast<unsigned int *> ((size_>-2) ? array_ : NULL); }
+  //@}
+  
+  /**@name Set methods */
+  //@{
+  /// Set the size
+  inline void setSize(int value) 
+  { size_ = value*CoinSizeofAsInt(unsigned int); }
+  //@}
+  
+  /**@name Condition methods */
+  //@{
+  /// Conditionally gets new array
+  inline unsigned int * conditionalNew(int sizeWanted)
+  { return reinterpret_cast<unsigned int *> (CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> (( sizeWanted)*CoinSizeofAsInt(unsigned int)) : -1)); }
+  //@}
+  
+  /**@name Constructors and destructors */
+  //@{
+  /** Default constructor - NULL*/
+  inline CoinUnsignedIntArrayWithLength()
+  { array_=NULL; size_=-1;}
+  /** Alternate Constructor - length in bytes - size_ -1 */
+  inline CoinUnsignedIntArrayWithLength(int size)
+  { array_=new char [size*CoinSizeofAsInt(unsigned int)]; size_=-1;}
+  /** Alternate Constructor - length in bytes 
+      mode -  0 size_ set to size
+      1 size_ set to size and zeroed
+  */
+  inline CoinUnsignedIntArrayWithLength(int size, int mode)
+    : CoinArrayWithLength(size*CoinSizeofAsInt(unsigned int),mode) {}
+  /** Copy constructor. */
+  inline CoinUnsignedIntArrayWithLength(const CoinUnsignedIntArrayWithLength & rhs)
+    : CoinArrayWithLength(rhs) {}
+  /** Copy constructor.2 */
+  inline CoinUnsignedIntArrayWithLength(const CoinUnsignedIntArrayWithLength * rhs)
+    : CoinArrayWithLength(rhs) {}
+  /** Assignment operator. */
+  inline CoinUnsignedIntArrayWithLength& operator=(const CoinUnsignedIntArrayWithLength & rhs)
+  { CoinArrayWithLength::operator=(rhs);  return *this;}
+  //@}
+};
+/// void * version
+
+class CoinVoidStarArrayWithLength : public CoinArrayWithLength {
+  
+public:
+  /**@name Get methods. */
+  //@{
+  /// Get the size
+  inline int getSize() const 
+  { return size_/CoinSizeofAsInt(void *); }
+  /// Get Array
+  inline void ** array() const 
+  { return reinterpret_cast<void **> ((size_>-2) ? array_ : NULL); }
+  //@}
+  
+  /**@name Set methods */
+  //@{
+  /// Set the size
+  inline void setSize(int value) 
+  { size_ = value*CoinSizeofAsInt(void *); }
+  //@}
+  
+  /**@name Condition methods */
+  //@{
+  /// Conditionally gets new array
+  inline void ** conditionalNew(int sizeWanted)
+  { return reinterpret_cast<void **> ( CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> ((sizeWanted)*CoinSizeofAsInt(void *)) : -1)); }
+  //@}
+  
+  /**@name Constructors and destructors */
+  //@{
+  /** Default constructor - NULL*/
+  inline CoinVoidStarArrayWithLength()
+  { array_=NULL; size_=-1;}
+  /** Alternate Constructor - length in bytes - size_ -1 */
+  inline CoinVoidStarArrayWithLength(int size)
+  { array_=new char [size*CoinSizeofAsInt(void *)]; size_=-1;}
+  /** Alternate Constructor - length in bytes 
+      mode -  0 size_ set to size
+      1 size_ set to size and zeroed
+  */
+  inline CoinVoidStarArrayWithLength(int size, int mode)
+    : CoinArrayWithLength(size*CoinSizeofAsInt(void *),mode) {}
+  /** Copy constructor. */
+  inline CoinVoidStarArrayWithLength(const CoinVoidStarArrayWithLength & rhs)
+    : CoinArrayWithLength(rhs) {}
+  /** Copy constructor.2 */
+  inline CoinVoidStarArrayWithLength(const CoinVoidStarArrayWithLength * rhs)
+    : CoinArrayWithLength(rhs) {}
+  /** Assignment operator. */
+  inline CoinVoidStarArrayWithLength& operator=(const CoinVoidStarArrayWithLength & rhs)
+  { CoinArrayWithLength::operator=(rhs);  return *this;}
+  //@}
+};
+/// arbitrary version
+
+class CoinArbitraryArrayWithLength : public CoinArrayWithLength {
+  
+public:
+  /**@name Get methods. */
+  //@{
+  /// Get the size
+  inline int getSize() const 
+  { return size_/lengthInBytes_; }
+  /// Get Array
+  inline void ** array() const 
+  { return reinterpret_cast<void **> ((size_>-2) ? array_ : NULL); }
+  //@}
+  
+  /**@name Set methods */
+  //@{
+  /// Set the size
+  inline void setSize(int value) 
+  { size_ = value*lengthInBytes_; }
+  //@}
+  
+  /**@name Condition methods */
+  //@{
+  /// Conditionally gets new array
+  inline char * conditionalNew(int length, int sizeWanted)
+  { lengthInBytes_=length;return reinterpret_cast<char *> ( CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> 
+									  ((sizeWanted)*lengthInBytes_) : -1)); }
+  //@}
+  
+  /**@name Constructors and destructors */
+  //@{
+  /** Default constructor - NULL*/
+  inline CoinArbitraryArrayWithLength(int length=1)
+  { array_=NULL; size_=-1;lengthInBytes_=length;}
+  /** Alternate Constructor - length in bytes - size_ -1 */
+  inline CoinArbitraryArrayWithLength(int length, int size)
+  { array_=new char [size*length]; size_=-1; lengthInBytes_=length;}
+  /** Alternate Constructor - length in bytes 
+      mode -  0 size_ set to size
+      1 size_ set to size and zeroed
+  */
+  inline CoinArbitraryArrayWithLength(int length, int size, int mode)
+    : CoinArrayWithLength(size*length,mode) {lengthInBytes_=length;}
+  /** Copy constructor. */
+  inline CoinArbitraryArrayWithLength(const CoinArbitraryArrayWithLength & rhs)
+    : CoinArrayWithLength(rhs) {}
+  /** Copy constructor.2 */
+  inline CoinArbitraryArrayWithLength(const CoinArbitraryArrayWithLength * rhs)
+    : CoinArrayWithLength(rhs) {}
+  /** Assignment operator. */
+  inline CoinArbitraryArrayWithLength& operator=(const CoinArbitraryArrayWithLength & rhs)
+  { CoinArrayWithLength::operator=(rhs);  return *this;}
+  //@}
+
+protected:
+  /**@name Private member data */
+  //@{
+  /// Length in bytes
+  int lengthInBytes_;
+   //@}
+};
+class CoinPartitionedVector : public CoinIndexedVector {
+  
+public:
+#ifndef COIN_PARTITIONS
+#define COIN_PARTITIONS 8
+#endif
+   /**@name Get methods. */
+   //@{
+   /// Get the size of a partition
+   inline int getNumElements(int partition) const { assert (partition<COIN_PARTITIONS);
+     return numberElementsPartition_[partition]; }
+   /// Get number of partitions
+   inline int getNumPartitions() const
+  { return numberPartitions_; }
+   /// Get the size
+   inline int getNumElements() const { return nElements_; }
+   /// Get starts
+  inline int startPartition(int partition) const  { assert (partition<=COIN_PARTITIONS);
+    return startPartition_[partition]; }
+   /// Get starts
+  inline const int * startPartitions() const
+  { return startPartition_; }
+   //@}
+ 
+   //-------------------------------------------------------------------
+   // Set indices and elements
+   //------------------------------------------------------------------- 
+   /**@name Set methods */
+   //@{
+   /// Set the size of a partition
+  inline void setNumElementsPartition(int partition, int value) { assert (partition<COIN_PARTITIONS);
+    if (numberPartitions_) numberElementsPartition_[partition]=value; }
+   /// Set the size of a partition (just for a tiny while)
+  inline void setTempNumElementsPartition(int partition, int value) { assert (partition<COIN_PARTITIONS);
+    numberElementsPartition_[partition]=value; }
+  /// Add up number of elements in partitions
+  void computeNumberElements();
+  /// Add up number of elements in partitions and pack and get rid of partitions
+  void compact();
+   /** Reserve space.
+   */
+   void reserve(int n);
+  /// Setup partitions (needs end as well)
+  void setPartitions(int number,const int * starts);
+   /// Reset the vector (as if were just created an empty vector). Gets rid of partitions
+   void clearAndReset();
+   /// Reset the vector (as if were just created an empty vector). Keeps partitions
+   void clearAndKeep();
+   /// Clear a partition.
+   void clearPartition(int partition);
+#ifndef NDEBUG
+   /// For debug check vector is clear i.e. no elements
+   void checkClear();
+   /// For debug check vector is clean i.e. elements match indices
+   void checkClean();
+#else
+  inline void checkClear() {};
+  inline void checkClean() {};
+#endif
+   /// Scan dense region and set up indices (returns number found)
+  int scan(int partition, double tolerance=0.0);
+   /** Scan dense region from start to < end and set up indices
+       returns number found
+   */
+   ///  Print out
+   void print() const;
+   //@}
+ 
+   /**@name Sorting */
+   //@{ 
+   /** Sort the indexed storage vector (increasing indices). */
+  void sort();
+   //@}
+
+   /**@name Constructors and destructors (not all wriiten) */
+   //@{
+   /** Default constructor */
+   CoinPartitionedVector();
+   /** Alternate Constructors - set elements to vector of doubles */
+  CoinPartitionedVector(int size, const int * inds, const double * elems);
+   /** Alternate Constructors - set elements to same scalar value */
+  CoinPartitionedVector(int size, const int * inds, double element);
+   /** Alternate Constructors - construct full storage with indices 0 through
+       size-1. */
+  CoinPartitionedVector(int size, const double * elements);
+   /** Alternate Constructors - just size */
+  CoinPartitionedVector(int size);
+   /** Copy constructor. */
+   CoinPartitionedVector(const CoinPartitionedVector &);
+   /** Copy constructor.2 */
+   CoinPartitionedVector(const CoinPartitionedVector *);
+   /** Assignment operator. */
+   CoinPartitionedVector & operator=(const CoinPartitionedVector &);
+   /** Destructor */
+   ~CoinPartitionedVector ();
+   //@}
+protected:
+   /**@name Private member data */
+   //@{
+   /// Starts
+   int startPartition_[COIN_PARTITIONS+1];
+   /// Size of indices in a partition
+   int numberElementsPartition_[COIN_PARTITIONS];
+  /// Number of partitions (0 means off)
+  int numberPartitions_;
+   //@}
+};
+#endif