diff options
Diffstat (limited to 'build/Bonmin/include/coin/CoinIndexedVector.hpp')
| -rw-r--r-- | build/Bonmin/include/coin/CoinIndexedVector.hpp | 1164 |
1 files changed, 0 insertions, 1164 deletions
diff --git a/build/Bonmin/include/coin/CoinIndexedVector.hpp b/build/Bonmin/include/coin/CoinIndexedVector.hpp deleted file mode 100644 index 9c386c5..0000000 --- a/build/Bonmin/include/coin/CoinIndexedVector.hpp +++ /dev/null @@ -1,1164 +0,0 @@ -/* $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 |