#include <AmbiVector.h>

Classes
class	Iterator

struct	ListEl

Public Types
typedef Scalar_	Scalar

typedef StorageIndex_	StorageIndex

typedef NumTraits< Scalar >::Real	RealScalar

Public Member Functions
	AmbiVector (Index size)

void	init (double estimatedDensity)

void	init (int mode)

Index	nonZeros () const

void	setBounds (Index start, Index end)

void	setZero ()

void	restart ()

Scalar &	coeffRef (Index i)

Scalar &	coeff (Index i)

	~AmbiVector ()

void	resize (Index size)

StorageIndex	size () const

Protected Member Functions
StorageIndex	convert_index (Index idx)

void	reallocate (Index size)

void	reallocateSparse ()

Protected Attributes
Scalar *	m_buffer

Scalar	m_zero

StorageIndex	m_size

StorageIndex	m_start

StorageIndex	m_end

StorageIndex	m_allocatedSize

StorageIndex	m_allocatedElements

StorageIndex	m_mode

StorageIndex	m_llStart

StorageIndex	m_llCurrent

StorageIndex	m_llSize

Detailed Description

template<typename Scalar_, typename StorageIndex_>
class Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >

Hybrid sparse/dense vector class designed for intensive read-write operations.

See BasicSparseLLT and SparseProduct for usage examples.

Member Typedef Documentation

◆ RealScalar

template<typename Scalar_ , typename StorageIndex_ >

typedef NumTraits<Scalar>::Real Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::RealScalar

◆ Scalar

template<typename Scalar_ , typename StorageIndex_ >

typedef Scalar_ Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::Scalar

◆ StorageIndex

template<typename Scalar_ , typename StorageIndex_ >

typedef StorageIndex_ Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::StorageIndex

Constructor & Destructor Documentation

◆ AmbiVector()

template<typename Scalar_ , typename StorageIndex_ >

Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::AmbiVector ( Index size )

inlineexplicit

       : m_buffer(0), m_zero(0), m_size(0), m_end(0), m_allocatedSize(0), m_allocatedElements(0), m_mode(-1) {
     resize(size);
   }

References Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::resize(), and Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::size().

◆ ~AmbiVector()

template<typename Scalar_ , typename StorageIndex_ >

Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::~AmbiVector ( )

inline

56 { delete[] m_buffer; }

References Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::m_buffer.

Member Function Documentation

◆ coeff()

template<typename Scalar_ , typename StorageIndex_ >

Scalar_ & Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::coeff ( Index i )

                                                           {
   if (m_mode == IsDense)
     return m_buffer[i];
   else {
     ListEl* EIGEN_RESTRICT llElements = reinterpret_cast<ListEl*>(m_buffer);
     eigen_assert(m_mode == IsSparse);
     if ((m_llSize == 0) || (i < llElements[m_llStart].index)) {
       return m_zero;
     } else {
       Index elid = m_llStart;
       while (elid >= 0 && llElements[elid].index < i) elid = llElements[elid].next;
  
       if (llElements[elid].index == i)
         return llElements[m_llCurrent].value;
       else
         return m_zero;
     }
   }
 }

References eigen_assert, EIGEN_RESTRICT, i, Eigen::IsDense, and Eigen::IsSparse.

◆ coeffRef()

template<typename Scalar_ , typename StorageIndex_ >

Scalar_ & Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::coeffRef ( Index i )

                                                              {
   if (m_mode == IsDense)
     return m_buffer[i];
   else {
     ListEl* EIGEN_RESTRICT llElements = reinterpret_cast<ListEl*>(m_buffer);
     // TODO factorize the following code to reduce code generation
     eigen_assert(m_mode == IsSparse);
     if (m_llSize == 0) {
       // this is the first element
       m_llStart = 0;
       m_llCurrent = 0;
       ++m_llSize;
       llElements[0].value = Scalar(0);
       llElements[0].index = convert_index(i);
       llElements[0].next = -1;
       return llElements[0].value;
     } else if (i < llElements[m_llStart].index) {
       // this is going to be the new first element of the list
       ListEl& el = llElements[m_llSize];
       el.value = Scalar(0);
       el.index = convert_index(i);
       el.next = m_llStart;
       m_llStart = m_llSize;
       ++m_llSize;
       m_llCurrent = m_llStart;
       return el.value;
     } else {
       StorageIndex nextel = llElements[m_llCurrent].next;
       eigen_assert(i >= llElements[m_llCurrent].index &&
                    "you must call restart() before inserting an element with lower or equal index");
       while (nextel >= 0 && llElements[nextel].index <= i) {
         m_llCurrent = nextel;
         nextel = llElements[nextel].next;
       }
  
       if (llElements[m_llCurrent].index == i) {
         // the coefficient already exists and we found it !
         return llElements[m_llCurrent].value;
       } else {
         if (m_llSize >= m_allocatedElements) {
           reallocateSparse();
           llElements = reinterpret_cast<ListEl*>(m_buffer);
         }
         eigen_internal_assert(m_llSize < m_allocatedElements && "internal error: overflow in sparse mode");
         // let's insert a new coefficient
         ListEl& el = llElements[m_llSize];
         el.value = Scalar(0);
         el.index = convert_index(i);
         el.next = llElements[m_llCurrent].next;
         llElements[m_llCurrent].next = m_llSize;
         ++m_llSize;
         return el.value;
       }
     }
   }
 }

References Eigen::internal::convert_index(), eigen_assert, eigen_internal_assert, EIGEN_RESTRICT, CRBond_Bessel::el, i, Eigen::IsDense, and Eigen::IsSparse.

Referenced by Eigen::internal::sparse_solve_triangular_sparse_selector< Lhs, Rhs, Mode, UpLo, ColMajor >::run(), and Eigen::internal::sparse_sparse_product_with_pruning_impl().

◆ convert_index()

template<typename Scalar_ , typename StorageIndex_ >

StorageIndex Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::convert_index ( Index idx )

inlineprotected

66 { return internal::convert_index<StorageIndex>(idx); }

Referenced by Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::reallocate(), Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::resize(), and Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::setBounds().

◆ init() [1/2]

template<typename Scalar_ , typename StorageIndex_ >

void Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::init ( double estimatedDensity )

                                                                      {
   if (estimatedDensity > 0.1)
     init(IsDense);
   else
     init(IsSparse);
 }

References Eigen::IsDense, and Eigen::IsSparse.

Referenced by Eigen::internal::sparse_solve_triangular_sparse_selector< Lhs, Rhs, Mode, UpLo, ColMajor >::run(), and Eigen::internal::sparse_sparse_product_with_pruning_impl().

◆ init() [2/2]

template<typename Scalar_ , typename StorageIndex_ >

void Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::init ( int mode )

                                                       {
   m_mode = mode;
   // This is only necessary in sparse mode, but we set these unconditionally to avoid some maybe-uninitialized warnings
   // if (m_mode==IsSparse)
   {
     m_llSize = 0;
     m_llStart = -1;
   }
 }

◆ nonZeros()

template<typename Scalar_ , typename StorageIndex_ >

Index Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::nonZeros

Returns: the number of non zeros in the current sub vector

                                                          {
   if (m_mode == IsSparse)
     return m_llSize;
   else
     return m_end - m_start;
 }

References Eigen::IsSparse.

◆ reallocate()

template<typename Scalar_ , typename StorageIndex_ >

void Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::reallocate ( Index size )

inlineprotected

                               {
     // if the size of the matrix is not too large, let's allocate a bit more than needed such
     // that we can handle dense vector even in sparse mode.
     delete[] m_buffer;
     if (size < 1000) {
       Index allocSize = (size * sizeof(ListEl) + sizeof(Scalar) - 1) / sizeof(Scalar);
       m_allocatedElements = convert_index((allocSize * sizeof(Scalar)) / sizeof(ListEl));
       m_buffer = new Scalar[allocSize];
     } else {
       m_allocatedElements = convert_index((size * sizeof(Scalar)) / sizeof(ListEl));
       m_buffer = new Scalar[size];
     }
     m_size = convert_index(size);
     m_start = 0;
     m_end = m_size;
   }

References Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::convert_index(), Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::m_allocatedElements, Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::m_buffer, Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::m_end, Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::m_size, Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::m_start, and Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::size().

Referenced by Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::resize().

◆ reallocateSparse()

template<typename Scalar_ , typename StorageIndex_ >

void Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::reallocateSparse ( )

inlineprotected

                           {
     Index copyElements = m_allocatedElements;
     m_allocatedElements = (std::min)(StorageIndex(m_allocatedElements * 1.5), m_size);
     Index allocSize = m_allocatedElements * sizeof(ListEl);
     allocSize = (allocSize + sizeof(Scalar) - 1) / sizeof(Scalar);
     Scalar* newBuffer = new Scalar[allocSize];
     std::memcpy(newBuffer, m_buffer, copyElements * sizeof(ListEl));
     delete[] m_buffer;
     m_buffer = newBuffer;
   }

References Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::m_allocatedElements, Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::m_buffer, Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::m_size, and min.

◆ resize()

template<typename Scalar_ , typename StorageIndex_ >

void Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::resize ( Index size )

inline

                           {
     if (m_allocatedSize < size) reallocate(size);
     m_size = convert_index(size);
   }

References Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::convert_index(), Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::m_allocatedSize, Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::m_size, Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::reallocate(), and Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::size().

Referenced by Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::AmbiVector().

◆ restart()

template<typename Scalar_ , typename StorageIndex_ >

void Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::restart

Must be called whenever we might perform a write access with an index smaller than the previous one.

Don't worry, this function is extremely cheap.

                                                  {
   m_llCurrent = m_llStart;
 }

Referenced by Eigen::internal::sparse_solve_triangular_sparse_selector< Lhs, Rhs, Mode, UpLo, ColMajor >::run(), and Eigen::internal::sparse_sparse_product_with_pruning_impl().

◆ setBounds()

template<typename Scalar_ , typename StorageIndex_ >

void Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::setBounds	(	Index	start,
		Index	end
	)

inline

Specifies a sub-vector to work on

                                          {
     m_start = convert_index(start);
     m_end = convert_index(end);
   }

References Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::convert_index(), Eigen::placeholders::end, Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::m_end, Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::m_start, and oomph::CumulativeTimings::start().

Referenced by Eigen::internal::sparse_solve_triangular_sparse_selector< Lhs, Rhs, Mode, UpLo, ColMajor >::run().

◆ setZero()

template<typename Scalar_ , typename StorageIndex_ >

void Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::setZero

Set all coefficients of current subvector to zero

                                                  {
   if (m_mode == IsDense) {
     for (Index i = m_start; i < m_end; ++i) m_buffer[i] = Scalar(0);
   } else {
     eigen_assert(m_mode == IsSparse);
     m_llSize = 0;
     m_llStart = -1;
   }
 }