CoinPackedVector Class Reference

#include <CoinPackedVector.hpp>

Inheritance diagram for CoinPackedVector:

List of all members.

Public Member Functions
Get methods.
virtual int	getNumElements () const
	Get the size.
virtual const int *	getIndices () const
	Get indices of elements.
virtual const double *	getElements () const
	Get element values.
int *	getIndices ()
	Get indices of elements.
double *	getElements ()
	Get element values.
const int *	getOriginalPosition () const
Set methods
void	clear ()
	Reset the vector (as if were just created an empty vector).
CoinPackedVector &	operator= (const CoinPackedVector &)
CoinPackedVector &	operator= (const CoinPackedVectorBase &rhs)
void	assignVector (int size, int *&inds, double *&elems, bool testForDuplicateIndex=true)
void	setVector (int size, const int *inds, const double *elems, bool testForDuplicateIndex=true) throw (CoinError)
void	setConstant (int size, const int *inds, double elems, bool testForDuplicateIndex=true) throw (CoinError)
void	setFull (int size, const double *elems, bool testForDuplicateIndex=true)
void	setFullNonZero (int size, const double *elems, bool testForDuplicateIndex=true)
void	setElement (int index, double element) throw (CoinError)
void	insert (int index, double element) throw (CoinError)
	Insert an element into the vector.
void	append (const CoinPackedVectorBase &caboose) throw (CoinError)
	Append a CoinPackedVector to the end.
void	swap (int i, int j) throw (CoinError)
	Swap values in positions i and j of indices and elements.
void	truncate (int newSize) throw (CoinError)
Arithmetic operators.
void	operator+= (double value)
	add value to every entry
void	operator-= (double value)
	subtract value from every entry
void	operator *= (double value)
	multiply every entry by value
void	operator/= (double value)
	divide every entry by value
Sorting
template<class CoinCompare3> void	sort (const CoinCompare3 &tc)
void	sortIncrIndex ()
void	sortDecrIndex ()
void	sortIncrElement ()
void	sortDecrElement ()
void	sortOriginalOrder ()
Memory usage
void	reserve (int n)
int	capacity () const
Constructors and destructors
	CoinPackedVector (bool testForDuplicateIndex=true)
	CoinPackedVector (int size, const int *inds, const double *elems, bool testForDuplicateIndex=true)
	CoinPackedVector (int size, const int *inds, double element, bool testForDuplicateIndex=true)
	CoinPackedVector (int size, const double *elements, bool testForDuplicateIndex=true)
	CoinPackedVector (const CoinPackedVector &)
	CoinPackedVector (const CoinPackedVectorBase &rhs)
virtual	~CoinPackedVector ()
Private Member Functions
Private methods
void	gutsOfSetVector (int size, const int *inds, const double *elems, bool testForDuplicateIndex, const char *method)
	Copy internal date.
void	gutsOfSetConstant (int size, const int *inds, double value, bool testForDuplicateIndex, const char *method)
Private Attributes
Private member data
int *	indices_
	Vector indices.
double *	elements_
	Vector elements.
int	nElements_
	Size of indices and elements vectors.
int *	origIndices_
	original unsorted indices
int	capacity_
	Amount of memory allocated for indices_, origIndices_, and elements_.
Friends
void	CoinPackedVectorUnitTest ()

---

Detailed Description

Sparse Vector

Stores vector of indices and associated element values. Supports sorting of vector while maintaining the original indices.

Here is a sample usage:

    const int ne = 4;
    int inx[ne] =   {  1,   4,  0,   2 };
    double el[ne] = { 10., 40., 1., 50. };

    // Create vector and set its value
    CoinPackedVector r(ne,inx,el);

    // access each index and element
    assert( r.indices ()[0]== 1  );
    assert( r.elements()[0]==10. );
    assert( r.indices ()[1]== 4  );
    assert( r.elements()[1]==40. );
    assert( r.indices ()[2]== 0  );
    assert( r.elements()[2]== 1. );
    assert( r.indices ()[3]== 2  );
    assert( r.elements()[3]==50. );

    // access original position of index
    assert( r.originalPosition()[0]==0 );
    assert( r.originalPosition()[1]==1 );
    assert( r.originalPosition()[2]==2 );
    assert( r.originalPosition()[3]==3 );

    // 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.indices ()[0]== 0  );
    assert( r.elements()[0]== 1. );
    assert( r.indices ()[1]== 1  );
    assert( r.elements()[1]==10. );
    assert( r.indices ()[2]== 4  );
    assert( r.elements()[2]==40. );
    assert( r.indices ()[3]== 2  );
    assert( r.elements()[3]==50. );    

    // access original position of index    
    assert( r.originalPosition()[0]==2 );
    assert( r.originalPosition()[1]==0 );
    assert( r.originalPosition()[2]==1 );
    assert( r.originalPosition()[3]==3 );

    // 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.);

    // Restore orignal sort order
    r.sortOriginalOrder();
    
    assert( r.indices ()[0]== 1  );
    assert( r.elements()[0]==10. );
    assert( r.indices ()[1]== 4  );
    assert( r.elements()[1]==40. );
    assert( r.indices ()[2]== 0  );
    assert( r.elements()[2]== 1. );
    assert( r.indices ()[3]== 2  );
    assert( r.elements()[3]==50. );

    // Tests for equality and equivalence
    CoinPackedVector r1;
    r1=r;
    assert( r==r1 );
    assert( r.equivalent(r1) );
    r.sortIncrElement();
    assert( r!=r1 );
    assert( r.equivalent(r1) );

    // Add packed vectors.
    // Similarly for subtraction, multiplication,
    // and division.
    CoinPackedVector 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. );

Definition at line 113 of file CoinPackedVector.hpp.

---

Constructor & Destructor Documentation

CoinPackedVector::CoinPackedVector (  bool  testForDuplicateIndex = true  )

Default constructor Definition at line 344 of file CoinPackedVector.cpp. References CoinPackedVectorBase::setTestForDuplicateIndex(). : CoinPackedVectorBase(), indices_(NULL), elements_(NULL), nElements_(0), origIndices_(NULL), capacity_(0) { // This won't fail, the packed vector is empty. There can't be duplicate // indices. CoinPackedVectorBase::setTestForDuplicateIndex(testForDuplicateIndex); }

CoinPackedVector::CoinPackedVector (  int  size, const int *  inds, const double *  elems, bool  testForDuplicateIndex = true )

Alternate Constructors - set elements to vector of doubles Definition at line 359 of file CoinPackedVector.cpp. References gutsOfSetVector(). : CoinPackedVectorBase(), indices_(NULL), elements_(NULL), nElements_(0), origIndices_(NULL), capacity_(0) { gutsOfSetVector(size, inds, elems, testForDuplicateIndex, "constructor for array value"); }

CoinPackedVector::CoinPackedVector (  int  size, const int *  inds, double  element, bool  testForDuplicateIndex = true )

Alternate Constructors - set elements to same scalar value Definition at line 375 of file CoinPackedVector.cpp. : CoinPackedVectorBase(), indices_(NULL), elements_(NULL), nElements_(0), origIndices_(NULL), capacity_(0) { gutsOfSetConstant(size, inds, value, testForDuplicateIndex, "constructor for constant value"); }

CoinPackedVector::CoinPackedVector (  int  size, const double *  elements, bool  testForDuplicateIndex = true )

Alternate Constructors - construct full storage with indices 0 through size-1. Definition at line 391 of file CoinPackedVector.cpp. References setFull(). : CoinPackedVectorBase(), indices_(NULL), elements_(NULL), nElements_(0), origIndices_(NULL), capacity_(0) { setFull(size, element, testForDuplicateIndex); }

CoinPackedVector::CoinPackedVector (  const CoinPackedVector &   )

Copy constructor. Definition at line 419 of file CoinPackedVector.cpp. References gutsOfSetVector(). : CoinPackedVectorBase(), indices_(NULL), elements_(NULL), nElements_(0), origIndices_(NULL), capacity_(0) { gutsOfSetVector(rhs.getNumElements(), rhs.getIndices(), rhs.getElements(), rhs.testForDuplicateIndex(), "copy constructor"); }

CoinPackedVector::CoinPackedVector (  const CoinPackedVectorBase &  rhs  )

Copy constructor from a PackedVectorBase. Definition at line 405 of file CoinPackedVector.cpp. References gutsOfSetVector(). : CoinPackedVectorBase(), indices_(NULL), elements_(NULL), nElements_(0), origIndices_(NULL), capacity_(0) { gutsOfSetVector(rhs.getNumElements(), rhs.getIndices(), rhs.getElements(), rhs.testForDuplicateIndex(), "copy constructor from base"); }

CoinPackedVector::~CoinPackedVector (   )  [virtual]

Destructor Definition at line 433 of file CoinPackedVector.cpp. References elements_, indices_, and origIndices_. { delete [] indices_; delete [] origIndices_; delete [] elements_; }

---

Member Function Documentation

void CoinPackedVector::assignVector (  int  size, int *&  inds, double *&  elems, bool  testForDuplicateIndex = true )

Assign the ownership of the arguments to this vector. Size is the length of both the indices and elements vectors. The indices and elements vectors are copied into this class instance's member data. The last argument indicates whether this vector will have to be tested for duplicate indices. Definition at line 74 of file CoinPackedVector.cpp. References capacity_, clear(), elements_, indices_, nElements_, origIndices_, and CoinPackedVectorBase::setTestForDuplicateIndex(). { clear(); // Allocate storage if ( size != 0 ) { //reserve(size); //This is a BUG!!! nElements_ = size; if (indices_ != NULL) delete[] indices_; indices_ = inds; inds = NULL; if (elements_ != NULL) delete[] elements_; elements_ = elems; elems = NULL; if (origIndices_ != NULL) delete[] origIndices_; origIndices_ = new int[size]; CoinIotaN(origIndices_, size, 0); capacity_ = size; } try { CoinPackedVectorBase::setTestForDuplicateIndex(testForDuplicateIndex); } catch (CoinError e) { throw CoinError("duplicate index", "assignVector", "CoinPackedVector"); } }

int CoinPackedVector::capacity (   )  const [inline]

capacity returns the size which could be accomodated without having to reallocate storage. Definition at line 261 of file CoinPackedVector.hpp. References capacity_. { return capacity_; }

const int* CoinPackedVector::getOriginalPosition (   )  const [inline]

Get pointer to int * vector of original postions. If the packed vector has not been sorted then this function returns the vector: 0, 1, 2, ..., size()-1. Definition at line 132 of file CoinPackedVector.hpp. References origIndices_. { return origIndices_; }

CoinPackedVector & CoinPackedVector::operator= (  const CoinPackedVectorBase &  rhs  )

Assignment operator from a CoinPackedVectorBase. NOTE: This operator keeps the current testForDuplicateIndex setting, and affter copying the data it acts accordingly. Reimplemented from CoinPackedVectorBase. Definition at line 39 of file CoinPackedVector.cpp. References clear(), CoinPackedVectorBase::getElements(), CoinPackedVectorBase::getIndices(), CoinPackedVectorBase::getNumElements(), gutsOfSetVector(), and CoinPackedVectorBase::testForDuplicateIndex(). { if (this != &rhs) { clear(); gutsOfSetVector(rhs.getNumElements(), rhs.getIndices(), rhs.getElements(), CoinPackedVectorBase::testForDuplicateIndex(), "operator= from base"); } return *this; }

CoinPackedVector & CoinPackedVector::operator= (  const CoinPackedVector &   )

Assignment operator. NOTE: This operator keeps the current testForDuplicateIndex setting, and affter copying the data it acts accordingly. Definition at line 25 of file CoinPackedVector.cpp. References clear(), getElements(), getIndices(), getNumElements(), gutsOfSetVector(), and CoinPackedVectorBase::testForDuplicateIndex(). { if (this != &rhs) { clear(); gutsOfSetVector(rhs.getNumElements(), rhs.getIndices(), rhs.getElements(), CoinPackedVectorBase::testForDuplicateIndex(), "operator="); } return *this; }

void CoinPackedVector::reserve (  int  n  )

Reserve space. If one knows the eventual size of the packed vector, then it may be more efficient to reserve the space. Definition at line 312 of file CoinPackedVector.cpp. References capacity_, elements_, indices_, nElements_, and origIndices_. Referenced by gutsOfSetVector(), setFull(), and setFullNonZero(). { // don't make allocated space smaller if ( n <= capacity_ ) return; capacity_ = n; // save pointers to existing data int * tempIndices = indices_; int * tempOrigIndices = origIndices_; double * tempElements = elements_; // allocate new space indices_ = new int [capacity_]; origIndices_ = new int [capacity_]; elements_ = new double [capacity_]; // copy data to new space if (nElements_ > 0) { CoinDisjointCopyN(tempIndices, nElements_, indices_); CoinDisjointCopyN(tempOrigIndices, nElements_, origIndices_); CoinDisjointCopyN(tempElements, nElements_, elements_); } // free old data delete [] tempElements; delete [] tempOrigIndices; delete [] tempIndices; }

void CoinPackedVector::setConstant (  int  size, const int *  inds, double  elems, bool  testForDuplicateIndex = true )  throw (CoinError)

Elements set to have the same scalar value Definition at line 115 of file CoinPackedVector.cpp. { clear(); gutsOfSetConstant(size, inds, value, testForDuplicateIndex, "setConstant"); }

void CoinPackedVector::setElement (  int  index, double  element )  throw (CoinError)

Set an existing element in the packed vector The first argument is the "index" into the elements() array Definition at line 176 of file CoinPackedVector.cpp. { if ( index >= nElements_ ) throw CoinError("index >= size()", "setElement", "CoinPackedVector"); if ( index < 0 ) throw CoinError("index < 0" , "setElement", "CoinPackedVector"); elements_[index] = element; }

void CoinPackedVector::setFull (  int  size, const double *  elems, bool  testForDuplicateIndex = true )

Indices are not specified and are taken to be 0,1,...,size-1 Definition at line 126 of file CoinPackedVector.cpp. References clear(), elements_, indices_, nElements_, origIndices_, reserve(), and CoinPackedVectorBase::setTestForDuplicateIndex(). Referenced by CoinPackedVector(). { // Clear out any values presently stored clear(); // Allocate storage if ( size!=0 ) { reserve(size); nElements_ = size; CoinIotaN(origIndices_, size, 0); CoinIotaN(indices_, size, 0); CoinDisjointCopyN(elems, size, elements_); } CoinPackedVectorBase::setTestForDuplicateIndex(testForDuplicateIndex); }

void CoinPackedVector::setFullNonZero (  int  size, const double *  elems, bool  testForDuplicateIndex = true )

Indices are not specified and are taken to be 0,1,...,size-1, but only where non zero Definition at line 149 of file CoinPackedVector.cpp. References clear(), elements_, indices_, nElements_, origIndices_, reserve(), and CoinPackedVectorBase::setTestForDuplicateIndex(). { // Clear out any values presently stored clear(); // For now waste space // Allocate storage if ( size!=0 ) { reserve(size); nElements_ = 0; int i; for (i=0;i<size;i++) { if (elems[i]) { origIndices_[nElements_]= i; indices_[nElements_]= i; elements_[nElements_++] = elems[i]; } } } CoinPackedVectorBase::setTestForDuplicateIndex(testForDuplicateIndex); }

void CoinPackedVector::setVector (  int  size, const int *  inds, const double *  elems, bool  testForDuplicateIndex = true )  throw (CoinError)

Set vector size, indices, and elements. Size is the length of both the indices and elements vectors. The indices and elements vectors are copied into this class instance's member data. The last argument specifies whether this vector will have to be checked for duplicate indices whenever that can happen. Definition at line 104 of file CoinPackedVector.cpp. { clear(); gutsOfSetVector(size, inds, elems, testForDuplicateIndex, "setVector"); }

template<class CoinCompare3> void CoinPackedVector::sort (  const CoinCompare3 &  tc  )  [inline]

Sort the packed storage vector. Typcical usages: packedVector.sort(CoinIncrIndexOrdered()); //increasing indices packedVector.sort(CoinIncrElementOrdered()); // increasing elements Definition at line 223 of file CoinPackedVector.hpp. References elements_, indices_, nElements_, and origIndices_. { CoinSort_3(indices_, indices_ + nElements_, origIndices_, elements_, tc); }

void CoinPackedVector::sortOriginalOrder (   )

Sort in original order. If the vector has been sorted, then this method restores to its orignal sort order. Definition at line 305 of file CoinPackedVector.cpp. References elements_, indices_, nElements_, and origIndices_. { CoinSort_3(origIndices_, origIndices_ + nElements_, indices_, elements_); }

void CoinPackedVector::truncate (  int  newSize  )  throw (CoinError)

Resize the packed vector to be the first newSize elements. Problem with truncate: what happens with origIndices_ ??? Definition at line 256 of file CoinPackedVector.cpp. { if ( n > nElements_ ) throw CoinError("n > size()","truncate","CoinPackedVector"); if ( n < 0 ) throw CoinError("n < 0","truncate","CoinPackedVector"); nElements_ = n; clearBase(); }

---

Friends And Related Function Documentation

void CoinPackedVectorUnitTest (   )  [friend]

A function that tests the methods in the CoinPackedVector 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. Definition at line 19 of file CoinPackedVectorTest.cpp. { int i; // Test default constructor { CoinPackedVector r; assert( r.indices_==NULL ); assert( r.origIndices_==NULL ); assert( r.elements_==NULL ); assert( r.getNumElements()==0 ); assert( r.capacity_==0); } // Test set and get methods const int ne = 4; int inx[ne] = { 1, 3, 4, 7 }; double el[ne] = { 1.2, 3.4, 5.6, 7.8 }; { CoinPackedVector r; assert( r.getNumElements()==0 ); // Test setting/getting elements with int* & float* vectors r.setVector( ne, inx, el ); assert( r.getNumElements()==ne ); for ( i=0; i<ne; i++ ) { assert( r.getIndices()[i] == inx[i] ); assert( r.getOriginalPosition()[i] == i ); assert( r.getElements()[i] == el[i] ); } assert ( r.getMaxIndex()==7 ); assert ( r.getMinIndex()==1 ); // Test setting/getting elements with indices out of order const int ne2 = 5; int inx2[ne2] = { 2, 4, 8, 14, 3 }; double el2[ne2] = { 2.2, 4.4, 6.6, 8.8, 3.3 }; r.setVector(ne2,inx2,el2); assert( r.getNumElements()==ne2 ); assert( r.getIndices()[0]==inx2[0] ); assert( r.getOriginalPosition()[0]==0 ); assert( r.getElements()[0]==el2[0] ); assert( r.getIndices()[1]==inx2[1] ); assert( r.getOriginalPosition()[1]==1 ); assert( r.getElements()[1]==el2[1] ); assert( r.getIndices()[2]==inx2[2] ); assert( r.getOriginalPosition()[2]==2 ); assert( r.getElements()[2]==el2[2] ); assert( r.getIndices()[3]==inx2[3] ); assert( r.getOriginalPosition()[3]==3 ); assert( r.getElements()[3]==el2[3] ); assert( r.getIndices()[4]==inx2[4] ); assert( r.getOriginalPosition()[4]==4 ); assert( r.getElements()[4]==el2[4] ); assert ( r.getMaxIndex()==14 ); assert ( r.getMinIndex()==2 ); assert ( r.getMaxIndex()==14 ); assert ( r.getMinIndex()==2 ); { bool errorThrown = false; try { r.duplicateIndex(); } catch (CoinError e) { errorThrown = true; } assert( !errorThrown ); } CoinPackedVector r1(ne2,inx2,el2); assert( r == r1 ); // Test operator[] where index is duplicated // Causes exception to be thrown { const int ne3 = 4; int inx3[ne3] = { 2, 4, 2, 3 }; double el3[ne3] = { 2.2, 4.4, 8.8, 6.6 }; bool errorThrown = false; try { r.setVector(ne3,inx3,el3); } catch (CoinError e) { errorThrown = true; } assert( errorThrown ); errorThrown = false; try { r.duplicateIndex(); } catch (CoinError e) { errorThrown = true; } assert( errorThrown ); } // Test sorting by increasing elements r.setVector(ne2,inx2,el2); bool incr=true; for ( i=1; i<ne2; i++ ) if ( r.getElements()[i-1]>r.getElements()[i] ) incr=false; assert( !incr ); r.sortIncrElement(); incr = true; for ( i=1; i<ne2; i++ ) if ( r.getElements()[i-1]>r.getElements()[i] ) incr=false; assert( incr ); } { CoinPackedVector r; const int ne = 3; int inx[ne] = { 1, 2, 3 }; double el[ne] = { 2.2, 4.4, 8.8}; r.setVector(ne,inx,el); int c = r.capacity(); int max = r.getMaxIndex(); int min = r.getMinIndex(); // Test swap function r.swap(0,2); assert( r.getIndices()[0]==3 ); assert( r.getIndices()[1]==2 ); assert( r.getIndices()[2]==1 ); assert( r.getElements()[0]==8.8 ); assert( r.getElements()[1]==4.4 ); assert( r.getElements()[2]==2.2 ); assert( r.getMaxIndex() == max ); assert( r.getMinIndex() == min ); assert( r.capacity() == c ); // Test the append function CoinPackedVector s; const int nes = 4; int inxs[nes] = { 11, 12, 13, 14 }; double els[nes] = { .122, 14.4, 18.8, 19.9}; s.setVector(nes,inxs,els); r.append(s); assert( r.getNumElements()==7 ); assert( r.getIndices()[0]==3 ); assert( r.getIndices()[1]==2 ); assert( r.getIndices()[2]==1 ); assert( r.getIndices()[3]==11 ); assert( r.getIndices()[4]==12 ); assert( r.getIndices()[5]==13 ); assert( r.getIndices()[6]==14 ); assert( r.getElements()[0]==8.8 ); assert( r.getElements()[1]==4.4 ); assert( r.getElements()[2]==2.2 ); assert( r.getElements()[3]==.122 ); assert( r.getElements()[4]==14.4 ); assert( r.getElements()[5]==18.8 ); assert( r.getElements()[6]==19.9 ); assert( r.getMaxIndex() == 14 ); assert( r.getMinIndex() == 1 ); // Test the resize function c = r.capacity(); r.truncate(4); assert( r.getNumElements()==4 ); assert( r.getIndices()[0]==3 ); assert( r.getIndices()[1]==2 ); assert( r.getIndices()[2]==1 ); assert( r.getIndices()[3]==11 ); assert( r.getElements()[0]==8.8 ); assert( r.getElements()[1]==4.4 ); assert( r.getElements()[2]==2.2 ); assert( r.getElements()[3]==.122 ); assert( r.getMaxIndex() == 11 ); assert( r.getMinIndex() == 1 ); assert( r.capacity() == c ); } // Test copy constructor and assignment operator { CoinPackedVector rhs; { CoinPackedVector r; { CoinPackedVector rC1(r); assert( 0==r.getNumElements() ); assert( 0==rC1.getNumElements() ); r.setVector( ne, inx, el ); assert( ne==r.getNumElements() ); assert( 0==rC1.getNumElements() ); } CoinPackedVector rC2(r); assert( ne==r.getNumElements() ); assert( ne==rC2.getNumElements() ); for ( i=0; i<ne; i++ ) { assert( r.getIndices()[i] == rC2.getIndices()[i] ); assert( r.getOriginalPosition()[i] == rC2.getOriginalPosition()[i] ); assert( r.getElements()[i] == rC2.getElements()[i] ); } rhs=rC2; } // Test that rhs has correct values even though lhs has gone out of scope assert( rhs.getNumElements()==ne ); for ( i=0; i<ne; i++ ) { assert( inx[i] == rhs.getIndices()[i] ); assert( i == rhs.getOriginalPosition()[i] ); assert( el[i] == rhs.getElements()[i] ); } } // Test operator== { CoinPackedVector v1,v2; assert( v1==v2 ); assert( v2==v1 ); assert( v1==v1 ); assert( !(v1!=v2) ); assert( v1.isEquivalent(v2) ); assert( v2.isEquivalent(v1) ); assert( v1.isEquivalent(v1) ); v1.setVector( ne, inx, el ); assert ( !(v1==v2) ); assert ( v1!=v2 ); assert( !v1.isEquivalent(v2) ); CoinPackedVector v3(v1); assert( v3==v1 ); assert( v3!=v2 ); assert( v1.isEquivalent(v3) ); assert( v3.isEquivalent(v1) ); CoinPackedVector v4(v2); assert( v4!=v1 ); assert( v4==v2 ); } { // Test sorting of packed vectors const int ne = 4; int inx[ne] = { 1, 4, 0, 2 }; double el[ne] = { 10., 40., 1., 20. }; double extSortKey[5] = { -20., 10., 5., 4., 20. }; CoinPackedVector r; r.setVector(ne,inx,el); // Test that indices are in increasing order r.sortIncrIndex(); for ( i=1; i<ne; i++ ) assert( r.getIndices()[i-1] < r.getIndices()[i] ); // Sort by element values; r.sortIncrElement(); for ( i=1; i<ne; i++ ) assert( r.getElements()[i-1] < r.getElements()[i] ); // Sort using indices into an external sort vector CoinIncrSolutionOrdered pcSo(extSortKey); r.sort(pcSo); for ( i=1; i<ne; i++ ) assert( extSortKey[r.getIndices()[i-1]] < extSortKey[r.getIndices()[i]] ); // Now sort by indices. r.sortIncrIndex(); for ( i=1; i<ne; i++ ) assert( r.getIndices()[i-1] < r.getIndices()[i] ); } { // Test operator[] and indexExists() const int ne = 4; int inx[ne] = { 1, 4, 0, 2 }; double el[ne] = { 10., 40., 1., 50. }; CoinPackedVector r; assert( r[1]==0. ); r.setVector(ne,inx,el); assert( r[-1]==0. ); assert( r[ 0]==1. ); assert( r[ 1]==10.); assert( r[ 2]==50.); assert( r[ 3]==0. ); assert( r[ 4]==40.); assert( r[ 5]==0. ); assert( r.isExistingIndex(2) ); assert( !r.isExistingIndex(3) ); r.sortIncrElement(); assert( r[-1]==0. ); assert( r[ 0]==1. ); assert( r[ 1]==10.); assert( r[ 2]==50.); assert( r[ 3]==0. ); assert( r[ 4]==40.); assert( r[ 5]==0. ); assert( !r.isExistingIndex(-1) ); assert( r.isExistingIndex(0) ); assert( !r.isExistingIndex(3) ); assert( r.isExistingIndex(4) ); assert( !r.isExistingIndex(5) ); assert ( r.getMaxIndex()==4 ); assert ( r.getMinIndex()==0 ); } // Test that attemping to get min/max index of a 0, // length vector { CoinPackedVector nullVec; assert( nullVec.getMaxIndex() == /*std::numeric_limits<int>::max()*/INT_MIN/*0*/ ); assert( nullVec.getMinIndex() == /*std::numeric_limits<int>::min()*/INT_MAX/*0*/ ); } // Test CoinFltEq with equivalent method { const int ne = 4; int inx1[ne] = { 1, 3, 4, 7 }; double el1[ne] = { 1.2, 3.4, 5.6, 7.8 }; int inx2[ne] = { 7, 4, 3, 1 }; double el2[ne] = { 7.8+.5, 5.6+.5, 3.4+.5, 1.2+.5 }; CoinPackedVector v1,v2; v1.setVector(ne,inx1,el1); v2.setVector(ne,inx2,el2); assert( !v1.isEquivalent(v2) ); assert( v1.isEquivalent(v2,CoinAbsFltEq(.6)) ); assert( v1.isEquivalent(v2,CoinRelFltEq(.6)) ); } { // Test reserve CoinPackedVector v1,v2; assert( v1.capacity()==0 ); v1.reserve(6); assert( v1.capacity()==6 ); assert( v1.getNumElements()==0 ); v2=v1; assert( v2.capacity() == v2.getNumElements() ); assert( v2.getNumElements()==0 ); assert( v2==v1 ); v1.setVector(0,NULL,NULL); assert( v1.capacity()==6 ); assert( v1.getNumElements()==0 ); assert( v2==v1 ); v2=v1; assert( v2.capacity() == v2.getNumElements() ); assert( v2.getNumElements()==0 ); assert( v2==v1 ); const int ne = 2; int inx[ne] = { 1, 3 }; double el[ne] = { 1.2, 3.4 }; v1.setVector(ne,inx,el); assert( v1.capacity()==6 ); assert( v1.getNumElements()==2 ); v2=v1; assert( v2.capacity()==v2.getNumElements() ); assert( v2.getNumElements()==2 ); assert( v2==v1 ); const int ne1 = 5; int inx1[ne1] = { 1, 3, 4, 5, 6 }; double el1[ne1] = { 1.2, 3.4, 5., 6., 7. }; v1.setVector(ne1,inx1,el1); assert( v1.capacity()==6 ); assert( v1.getNumElements()==5 ); v2=v1; assert( v2.capacity()==v2.getNumElements() ); assert( v2.getNumElements()==5 ); assert( v2==v1 ); const int ne2 = 8; int inx2[ne2] = { 1, 3, 4, 5, 6, 7, 8, 9 }; double el2[ne2] = { 1.2, 3.4, 5., 6., 7., 8., 9., 10. }; v1.setVector(ne2,inx2,el2); assert( v1.capacity()==8 ); assert( v1.getNumElements()==8 ); v2=v1; assert( v2.capacity()==v2.getNumElements() ); assert( v2.getNumElements()==8 ); assert( v2==v1 ); v1.setVector(ne1,inx1,el1); assert( v1.capacity()==8 ); assert( v1.getNumElements()==5 ); v2=v1; assert( v2.capacity()==8 ); assert( v2.getNumElements()==5 ); assert( v2==v1 ); v1.reserve(7); assert( v1.capacity()==8 ); assert( v1.getNumElements()==5 ); v2=v1; assert( v2.capacity()==8 ); assert( v2.getNumElements()==5 ); assert( v2==v1 ); } // Test the insert method { CoinPackedVector v1; assert( v1.getNumElements()==0 ); assert( v1.capacity()==0 ); assert( !v1.isExistingIndex(1) ); v1.insert(1,1.); assert( v1.getNumElements()==1 ); assert( v1.capacity()==5 ); assert( v1.getIndices()[0] == 1 ); assert( v1.getElements()[0] == 1. ); assert( v1.isExistingIndex(1) ); assert( !v1.isExistingIndex(10) ); v1.insert(10,10.); assert( v1.getNumElements()==2 ); assert( v1.capacity()==5 ); assert( v1.getIndices()[1] == 10 ); assert( v1.getElements()[1] == 10. ); assert( v1.isExistingIndex(1) ); assert( v1.isExistingIndex(10) ); assert( !v1.isExistingIndex(20) ); v1.insert(20,20.); assert( v1.getNumElements()==3 ); assert( v1.capacity()==5 ); assert( v1.getIndices()[2] == 20 ); assert( v1.getElements()[2] == 20. ); assert( v1.isExistingIndex(20) ); assert( !v1.isExistingIndex(30) ); v1.insert(30,30.); assert( v1.getNumElements()==4 ); assert( v1.capacity()==5 ); assert( v1.getIndices()[3] == 30 ); assert( v1.getElements()[3] == 30. ); assert( v1.isExistingIndex(30) ); assert( !v1.isExistingIndex(40) ); v1.insert(40,40.); assert( v1.getNumElements()==5 ); assert( v1.capacity()==5 ); assert( v1.getIndices()[4] == 40 ); assert( v1.getElements()[4] == 40. ); assert( v1.isExistingIndex(40) ); assert( !v1.isExistingIndex(50) ); v1.insert(50,50.); assert( v1.getNumElements()==6 ); assert( v1.capacity()==10 ); assert( v1.getIndices()[5] == 50 ); assert( v1.getElements()[5] == 50. ); assert( v1.isExistingIndex(50) ); CoinPackedVector v2; const int ne1 = 3; int inx1[ne1] = { 1, 3, 4 }; double el1[ne1] = { 1.2, 3.4, 5. }; v2.setVector(ne1,inx1,el1); assert( v2.getNumElements()==3 ); assert( v2.capacity()==3 ); } { //Test setConstant and setElement CoinPackedVector v2; const int ne1 = 3; int inx1[ne1] = { 1, 3, 4 }; v2.setConstant(ne1,inx1,3.14); assert( v2.getNumElements()==3 ); assert( v2.capacity()==3 ); assert( v2.getIndices()[0]==1 ); assert( v2.getElements()[0]==3.14 ); assert( v2.getIndices()[1]==3 ); assert( v2.getElements()[1]==3.14 ); assert( v2.getIndices()[2]==4 ); assert( v2.getElements()[2]==3.14 ); assert( v2[3] == 3.14 ); CoinPackedVector v2X(ne1,inx1,3.14); assert( v2 == v2X ); #if 0 v2.setElement( 1 , 100. ); assert( v2.getNumElements()==3 ); assert( v2.capacity()==3 ); assert( v2.getIndices()[0]==1 ); assert( v2.getElements()[0]==3.14 ); assert( v2.getIndices()[1]==3 ); assert( v2.getElements()[1]==100. ); assert( v2.getIndices()[2]==4 ); assert( v2.getElements()[2]==3.14 ); assert( v2[3] == 100. ); bool errorThrown = false; try { v2.setElement( 100, 100. ); } catch (CoinError e) { errorThrown = true; } assert( errorThrown ); #endif } { //Test setFull CoinPackedVector v2; const int ne2 = 3; double el2[ne2] = { 1., 3., 4. }; v2.setFull(ne2,el2); assert( v2.getNumElements()==3 ); assert( v2.capacity()==3 ); assert( v2.getIndices()[0]==0 ); assert( v2.getElements()[0]==1. ); assert( v2.getIndices()[1]==1 ); assert( v2.getElements()[1]==3. ); assert( v2.getIndices()[2]==2 ); assert( v2.getElements()[2]==4. ); assert( v2[1] == 3. ); CoinPackedVector v2X(ne2,el2); assert( v2 == v2X ); v2.setFull(0,el2); assert( v2[2] == 0. ); // Test setFullNonZero el2[1]=0.0; v2.setFullNonZero(ne2,el2); assert( v2.getNumElements()==2 ); assert( v2.capacity()==3 ); assert( v2.getIndices()[0]==0 ); assert( v2.getElements()[0]==1. ); assert( v2.getIndices()[1]==2 ); assert( v2.getElements()[1]==4. ); assert( v2[1] == 0. ); CoinPackedVector v2Y(ne2,el2); assert( v2 != v2Y ); assert( v2 != v2X ); } #if 0 // what happens when someone sets // the number of elements to be a negative number { const int ne = 4; int inx1[ne] = { 1, 3, 4, 7 }; double el1[ne] = { 1.2, 3.4, 5.6, 7.8 }; CoinPackedVector v1; v1.set(-ne,inx1,el1); } #endif // Test adding vectors { const int ne1 = 5; int inx1[ne1] = { 1, 3, 4, 7, 5 }; double el1[ne1] = { 1., 5., 6., 2., 9. }; const int ne2 = 4; int inx2[ne2] = { 7, 4, 2, 1 }; double el2[ne2] = { 7., 4., 2., 1. }; CoinPackedVector v1; v1.setVector(ne1,inx1,el1); CoinPackedVector v2; v2.setVector(ne2,inx2,el2); CoinPackedVector r = v1 + v2; const int ner = 6; int inxr[ner] = { 1, 2, 3, 4, 5, 7 }; double elr[ner] = { 1.+1., 0.+2., 5.+0., 6.+4., 9.+0., 2.+7. }; CoinPackedVector rV; rV.setVector(ner,inxr,elr); assert( r.isEquivalent(rV) ); } // Test subtracting vectors { const int ne1 = 5; int inx1[ne1] = { 1, 3, 4, 7, 5 }; double el1[ne1] = { 1., 5., 6., 2., 9. }; const int ne2 = 4; int inx2[ne2] = { 7, 4, 2, 1 }; double el2[ne2] = { 7., 4., 2., 1. }; CoinPackedVector v1; v1.setVector(ne1,inx1,el1); CoinPackedVector v2; v2.setVector(ne2,inx2,el2); CoinPackedVector r = v1 - v2; const int ner = 6; int inxr[ner] = { 1, 2, 3, 4, 5, 7 }; double elr[ner] = { 1.-1., 0.-2., 5.-0., 6.-4., 9.-0., 2.-7. }; CoinPackedVector rV; rV.setVector(ner,inxr,elr); assert( r.isEquivalent(rV) ); } // Test multiplying vectors { const int ne1 = 5; int inx1[ne1] = { 1, 3, 4, 7, 5 }; double el1[ne1] = { 1., 5., 6., 2., 9. }; const int ne2 = 4; int inx2[ne2] = { 7, 4, 2, 1 }; double el2[ne2] = { 7., 4., 2., 1. }; CoinPackedVector v1; v1.setVector(ne1,inx1,el1); CoinPackedVector v2; v2.setVector(ne2,inx2,el2); CoinPackedVector r = v1 * v2; const int ner = 6; int inxr[ner] = { 1, 2, 3, 4, 5, 7 }; double elr[ner] = { 1.*1., 0.*2., 5.*0., 6.*4., 9.*0., 2.*7. }; CoinPackedVector rV; rV.setVector(ner,inxr,elr); assert( r.isEquivalent(rV) ); } // Test dividing vectors { const int ne1 = 3; int inx1[ne1] = { 1, 4, 7 }; double el1[ne1] = { 1., 6., 2. }; const int ne2 = 4; int inx2[ne2] = { 7, 4, 2, 1 }; double el2[ne2] = { 7., 4., 2., 1. }; CoinPackedVector v1; v1.setVector(ne1,inx1,el1); CoinPackedVector v2; v2.setVector(ne2,inx2,el2); CoinPackedVector r = v1 / v2; const int ner = 4; int inxr[ner] = { 1, 2, 4, 7 }; double elr[ner] = { 1./1., 0./2., 6./4., 2./7. }; CoinPackedVector rV; rV.setVector(ner,inxr,elr); assert( r.isEquivalent(rV) ); } // Test sum { CoinPackedVector s; assert( s.sum() == 0 ); s.insert(25,45.); assert(s.sum()==45.); const int ne1 = 5; int inx1[ne1] = { 10, 3, 4, 7, 5 }; double el1[ne1] = { 1., 5., 6., 2., 9. }; s.setVector(ne1,inx1,el1); assert(s.sum()==1.+5.+6.+2.+9.); } // Just another interesting test { // Create numerator vector const int ne1 = 2; int inx1[ne1] = { 1, 4 }; double el1[ne1] = { 1., 6. }; CoinPackedVector v1(ne1,inx1,el1); // create denominator vector const int ne2 = 3; int inx2[ne2] = { 1, 2, 4 }; double el2[ne2] = { 1., 7., 4.}; CoinPackedVector v2(ne2,inx2,el2); // Compute ratio CoinPackedVector ratio = v1 / v2; // Sort ratios ratio.sortIncrElement(); // Test that the sort really worked assert( ratio.getElements()[0] == 0.0/7.0 ); assert( ratio.getElements()[1] == 1.0/1.0 ); assert( ratio.getElements()[2] == 6.0/4.0 ); // Get numerator of of sorted ratio vector assert( v1[ ratio.getIndices()[0] ] == 0.0 ); assert( v1[ ratio.getIndices()[1] ] == 1.0 ); assert( v1[ ratio.getIndices()[2] ] == 6.0 ); // Get denominator of of sorted ratio vector assert( v2[ ratio.getIndices()[0] ] == 7.0 ); assert( v2[ ratio.getIndices()[1] ] == 1.0 ); assert( v2[ ratio.getIndices()[2] ] == 4.0 ); } // Test copy constructor from ShallowPackedVector { const int ne = 4; int inx[ne] = { 1, 4, 0, 2 }; double el[ne] = { 10., 40., 1., 50. }; CoinPackedVector std(ne,inx,el); CoinShallowPackedVector * spvP = new CoinShallowPackedVector(ne,inx,el); CoinPackedVector pv(*spvP); assert( pv == std ); assert( pv.isEquivalent(std) ); delete spvP; assert( pv == std ); assert( pv.isEquivalent(std) ); pv.sortIncrElement(); assert( pv != std ); assert( pv.isEquivalent(std) ); } // Test assignment from ShallowPackedVector { const int ne = 4; int inx[ne] = { 1, 4, 0, 2 }; double el[ne] = { 10., 40., 1., 50. }; CoinPackedVector std(ne,inx,el); CoinShallowPackedVector * spvP = new CoinShallowPackedVector(ne,inx,el); CoinPackedVector pv; pv = *spvP; assert( pv == std ); assert( pv.isEquivalent(std) ); delete spvP; assert( pv == std ); assert( pv.isEquivalent(std) ); pv.sortIncrElement(); assert( pv != std ); assert( pv.isEquivalent(std) ); } { // Test that sample usage works const int ne = 4; int inx[ne] = { 1, 4, 0, 2 }; double el[ne] = { 10., 40., 1., 50. }; CoinPackedVector r(ne,inx,el); assert( r.getIndices()[0]== 1 ); assert( r.getElements()[0]==10. ); assert( r.getIndices()[1]== 4 ); assert( r.getElements()[1]==40. ); assert( r.getIndices()[2]== 0 ); assert( r.getElements()[2]== 1. ); assert( r.getIndices()[3]== 2 ); assert( r.getElements()[3]==50. ); assert( r.getOriginalPosition()[0]==0 ); assert( r.getOriginalPosition()[1]==1 ); assert( r.getOriginalPosition()[2]==2 ); assert( r.getOriginalPosition()[3]==3 ); assert( r[ 0]==1. ); assert( r[ 1]==10.); assert( r[ 2]==50.); assert( r[ 3]==0. ); assert( r[ 4]==40.); r.sortIncrElement(); assert( r.getIndices()[0]== 0 ); assert( r.getElements()[0]== 1. ); assert( r.getIndices()[1]== 1 ); assert( r.getElements()[1]==10. ); assert( r.getIndices()[2]== 4 ); assert( r.getElements()[2]==40. ); assert( r.getIndices()[3]== 2 ); assert( r.getElements()[3]==50. ); assert( r.getOriginalPosition()[0]==2 ); assert( r.getOriginalPosition()[1]==0 ); assert( r.getOriginalPosition()[2]==1 ); assert( r.getOriginalPosition()[3]==3 ); assert( r[ 0]==1. ); assert( r[ 1]==10.); assert( r[ 2]==50.); assert( r[ 3]==0. ); assert( r[ 4]==40.); r.sortOriginalOrder(); assert( r.getIndices()[0]== 1 ); assert( r.getElements()[0]==10. ); assert( r.getIndices()[1]== 4 ); assert( r.getElements()[1]==40. ); assert( r.getIndices()[2]== 0 ); assert( r.getElements()[2]== 1. ); assert( r.getIndices()[3]== 2 ); assert( r.getElements()[3]==50. ); CoinPackedVector r1; r1=r; assert( r==r1 ); assert( r.isEquivalent(r1) ); r.sortIncrElement(); assert( r!=r1 ); assert( r.isEquivalent(r1) ); CoinPackedVector 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. ); } { // Test findIndex const int ne = 4; int inx[ne] = { 1, -4, 0, 2 }; double el[ne] = { 10., 40., 1., 50. }; CoinPackedVector r(ne,inx,el); assert( r.findIndex(2) == 3 ); assert( r.findIndex(0) == 2 ); assert( r.findIndex(-4) == 1 ); assert( r.findIndex(1) == 0 ); assert( r.findIndex(3) == -1 ); } #if 0 { // Test construction with testing for duplicates as false const int ne = 4; int inx[ne] = { 1, -4, 0, 2 }; double el[ne] = { 10., 40., 1., 50. }; CoinPackedVector rT(ne,inx,el); CoinPackedVector r(false); assert( !r.isExistingIndex(1) ); r.insert(1,10.); assert( !r.isExistingIndex(-4) ); r.insert(-4,20.); assert( !r.isExistingIndex(0) ); r.insert(0,1.); assert( r.isExistingIndex(-4) ); // This line is failing!! // If r is constructed with true, // then it does not fail int neg4Index = r.findIndex(-4); assert( neg4Index == 1 ); r.setElement(neg4Index, r.getElements()[neg4Index] + 20); assert( !r.isExistingIndex(2) ); r.insert(2,50.); assert( r == rT ); } #endif }

---

The documentation for this class was generated from the following files:

• CoinPackedVector.hpp
• CoinPackedVector.cpp

---