#include <src/eigen/Eigen/src/SparseCore/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 >

Class Documentation

◆ Eigen::internal::AmbiVector::ListEl

struct Eigen::internal::AmbiVector::ListEl

template<typename _Scalar, typename _StorageIndex>
struct Eigen::internal::AmbiVector< _Scalar, _StorageIndex >::ListEl

Class Members
StorageIndex	index
StorageIndex	next
Scalar	value

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_allocatedSize(0), m_allocatedElements(0), m_mode(-1)
    {
      resize(size);
    }

References Eigen::internal::AmbiVector< _Scalar, _StorageIndex >::resize(), and Eigen::internal::AmbiVector< _Scalar, _StorageIndex >::size().

Here is the call graph for this function:

◆ ~AmbiVector()

template<typename _Scalar , typename _StorageIndex >

Eigen::internal::AmbiVector< _Scalar, _StorageIndex >::~AmbiVector ( )

inline

52{ 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, 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, Eigen::internal::AmbiVector< _Scalar, _StorageIndex >::ListEl::index, Eigen::IsDense, Eigen::IsSparse, Eigen::internal::AmbiVector< _Scalar, _StorageIndex >::ListEl::next, and Eigen::internal::AmbiVector< _Scalar, _StorageIndex >::ListEl::value.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ convert_index()

template<typename _Scalar , typename _StorageIndex >

StorageIndex Eigen::internal::AmbiVector< _Scalar, _StorageIndex >::convert_index ( Index idx )

inlineprotected

    {
      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().

Here is the caller graph for this function:

◆ 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().

Here is the caller graph for this function:

◆ init() [2/2]

template<typename _Scalar , typename _StorageIndex >

void Eigen::internal::AmbiVector< _Scalar, _StorageIndex >::init ( int mode )

{
  m_mode = mode;
  if (m_mode==IsSparse)
  {
    m_llSize = 0;
    m_llStart = -1;
  }
}

References Eigen::IsSparse.

◆ 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().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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, and Eigen::internal::AmbiVector< _Scalar, _StorageIndex >::m_size.

◆ 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().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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().

Here is the caller graph for this function:

◆ 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

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

Eigen::end

T * end(Slic3r::Mat< N, M, T > &mat)

Definition Point.hpp:608

References Eigen::internal::AmbiVector< _Scalar, _StorageIndex >::convert_index(), Eigen::end(), Eigen::internal::AmbiVector< _Scalar, _StorageIndex >::m_end, and Eigen::internal::AmbiVector< _Scalar, _StorageIndex >::m_start.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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;
  }
}