Shapeworks Studio: Eigen::internal::CompressedStorage< _Scalar, _Index > Class Template Reference

Shapeworks Studio 2.1

Shape analysis software suite

Public Types
typedef _Scalar	Scalar

typedef _Index	Index

Public Member Functions
	CompressedStorage (size_t size)

	CompressedStorage (const CompressedStorage &other)

CompressedStorage &	operator= (const CompressedStorage &other)

void	swap (CompressedStorage &other)

void	reserve (size_t size)

void	squeeze ()

void	resize (size_t size, float reserveSizeFactor=0)

void	append (const Scalar &v, Index i)

size_t	size () const

size_t	allocatedSize () const

void	clear ()

Scalar &	value (size_t i)

const Scalar &	value (size_t i) const

Index &	index (size_t i)

const Index &	index (size_t i) const

Index	searchLowerIndex (Index key) const

Index	searchLowerIndex (size_t start, size_t end, Index key) const

Scalar	at (Index key, const Scalar &defaultValue=Scalar(0)) const

Scalar	atInRange (size_t start, size_t end, Index key, const Scalar &defaultValue=Scalar(0)) const

Scalar &	atWithInsertion (Index key, const Scalar &defaultValue=Scalar(0))

void	prune (const Scalar &reference, const RealScalar &epsilon=NumTraits< RealScalar >::dummy_precision())

Static Public Member Functions
static CompressedStorage	Map (Index indices, Scalar values, size_t size)

Protected Types
typedef NumTraits< Scalar >::Real	RealScalar

Protected Member Functions
void	reallocate (size_t size)

Protected Attributes
Scalar *	m_values

Index *	m_indices

size_t	m_size

size_t	m_allocatedSize

Detailed Description

template<typename _Scalar, typename _Index>
class Eigen::internal::CompressedStorage< _Scalar, _Index >

Definition at line 22 of file CompressedStorage.h.

Member Function Documentation

template<typename _Scalar, typename _Index>

Scalar Eigen::internal::CompressedStorage< _Scalar, _Index >::at	(	Index	key,
		const Scalar &	defaultValue = `Scalar(0)`
	)		const

inline

Returns: the stored value at index key If the value does not exist, then the value defaultValue is returned without any insertion.

Definition at line 142 of file CompressedStorage.h.

     {
       if (m_size==0)
         return defaultValue;
       else if (key==m_indices[m_size-1])
         return m_values[m_size-1];
       // ^^  optimization: let's first check if it is the last coefficient
       // (very common in high level algorithms)
       const size_t id = searchLowerIndex(0,m_size-1,key);
       return ((id<m_size) && (m_indices[id]==key)) ? m_values[id] : defaultValue;
     }

template<typename _Scalar, typename _Index>

Scalar Eigen::internal::CompressedStorage< _Scalar, _Index >::atInRange	(	size_t	start,
		size_t	end,
		Index	key,
		const Scalar &	defaultValue = `Scalar(0)`
	)		const

inline

Like at(), but the search is performed in the range [start,end)

Definition at line 155 of file CompressedStorage.h.

     {
       if (start>=end)
         return Scalar(0);
       else if (end>start && key==m_indices[end-1])
         return m_values[end-1];
       // ^^  optimization: let's first check if it is the last coefficient
       // (very common in high level algorithms)
       const size_t id = searchLowerIndex(start,end-1,key);
       return ((id<end) && (m_indices[id]==key)) ? m_values[id] : defaultValue;
     }

template<typename _Scalar, typename _Index>

Scalar& Eigen::internal::CompressedStorage< _Scalar, _Index >::atWithInsertion	(	Index	key,
		const Scalar &	defaultValue = `Scalar(0)`
	)

inline

Returns: a reference to the value at index key If the value does not exist, then the value defaultValue is inserted such that the keys are sorted.

Definition at line 170 of file CompressedStorage.h.

     {
       size_t id = searchLowerIndex(0,m_size,key);
       if (id>=m_size || m_indices[id]!=key)
       {
         resize(m_size+1,1);
         for (size_t j=m_size-1; j>id; --j)
         {
           m_indices[j] = m_indices[j-1];
           m_values[j] = m_values[j-1];
         }
         m_indices[id] = key;
         m_values[id] = defaultValue;
       }
       return m_values[id];
     }

template<typename _Scalar, typename _Index>

Index Eigen::internal::CompressedStorage< _Scalar, _Index >::searchLowerIndex ( Index key ) const

inline

Returns: the largest k such that for all j in [0,k) index[j]<key

Definition at line 121 of file CompressedStorage.h.

     {
       return searchLowerIndex(0, m_size, key);
     }

template<typename _Scalar, typename _Index>

Index Eigen::internal::CompressedStorage< _Scalar, _Index >::searchLowerIndex	(	size_t	start,
		size_t	end,
		Index	key
	)		const

inline

Returns: the largest k in [start,end) such that for all j in [start,k) index[j]<key

Definition at line 127 of file CompressedStorage.h.

     {
       while(end>start)
       {
         size_t mid = (end+start)>>1;
         if (m_indices[mid]<key)
           start = mid+1;
         else
           end = mid;
       }
       return static_cast<Index>(start);
     }

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

C:/Users/Brig/Documents/ShapeWorksStudio/src/Surfworks/Eigen/src/SparseCore/CompressedStorage.h