Eigen::MapBase< Derived, ReadOnlyAccessors > Class Template Reference

Base class for dense Map and Block expression with direct access. More...

#include <MapBase.h>

Inheritance diagram for Eigen::MapBase< Derived, ReadOnlyAccessors >:

Public Types
enum	{ RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime , ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime , InnerStrideAtCompileTime = internal::traits<Derived>::InnerStrideAtCompileTime , SizeAtCompileTime = Base::SizeAtCompileTime }
typedef internal::dense_xpr_base< Derived >::type	Base
typedef internal::traits< Derived >::StorageKind	StorageKind
typedef internal::traits< Derived >::Scalar	Scalar
typedef internal::packet_traits< Scalar >::type	PacketScalar
typedef NumTraits< Scalar >::Real	RealScalar
typedef std::conditional_t< bool(internal::is_lvalue< Derived >::value), Scalar *, const Scalar * >	PointerType
typedef Base::CoeffReturnType	CoeffReturnType

Public Member Functions
EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index	rows () const EIGEN_NOEXCEPT
EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index	cols () const EIGEN_NOEXCEPT
constexpr EIGEN_DEVICE_FUNC const Scalar *	data () const
EIGEN_DEVICE_FUNC const Scalar &	coeff (Index rowId, Index colId) const
EIGEN_DEVICE_FUNC const Scalar &	coeff (Index index) const
EIGEN_DEVICE_FUNC const Scalar &	coeffRef (Index rowId, Index colId) const
EIGEN_DEVICE_FUNC const Scalar &	coeffRef (Index index) const
template<int LoadMode>
PacketScalar	packet (Index rowId, Index colId) const
template<int LoadMode>
PacketScalar	packet (Index index) const
EIGEN_DEVICE_FUNC	MapBase (PointerType dataPtr)
EIGEN_DEVICE_FUNC	MapBase (PointerType dataPtr, Index vecSize)
EIGEN_DEVICE_FUNC	MapBase (PointerType dataPtr, Index rows, Index cols)

Protected Member Functions
template<typename T >
EIGEN_DEVICE_FUNC void	checkSanity (std::enable_if_t<(internal::traits< T >::Alignment > 0), void * >=0) const
template<typename T >
EIGEN_DEVICE_FUNC void	checkSanity (std::enable_if_t< internal::traits< T >::Alignment==0, void * >=0) const

Protected Attributes
PointerType	m_data
const internal::variable_if_dynamic< Index, RowsAtCompileTime >	m_rows
const internal::variable_if_dynamic< Index, ColsAtCompileTime >	m_cols

Detailed Description

template<typename Derived>
class Eigen::MapBase< Derived, ReadOnlyAccessors >

Base class for dense Map and Block expression with direct access.

This base class provides the const low-level accessors (e.g. coeff, coeffRef) of dense Map and Block objects with direct access. Typical users do not have to directly deal with this class.

This class can be extended by through the macro plugin EIGEN_MAPBASE_PLUGIN. See customizing Eigen for details.

The Derived class has to provide the following two methods describing the memory layout:

Index innerStride() const; 

Index outerStride() const; 

See also

class Map, class Block

Member Typedef Documentation

Base

template<typename Derived >

typedef internal::dense_xpr_base<Derived>::type Eigen::MapBase< Derived, ReadOnlyAccessors >::Base

CoeffReturnType

template<typename Derived >

typedef Base::CoeffReturnType Eigen::MapBase< Derived, ReadOnlyAccessors >::CoeffReturnType

PacketScalar

template<typename Derived >

typedef internal::packet_traits<Scalar>::type Eigen::MapBase< Derived, ReadOnlyAccessors >::PacketScalar

PointerType

template<typename Derived >

typedef std::conditional_t<bool(internal::is_lvalue<Derived>::value), Scalar*, const Scalar*> Eigen::MapBase< Derived, ReadOnlyAccessors >::PointerType

RealScalar

template<typename Derived >

typedef NumTraits<Scalar>::Real Eigen::MapBase< Derived, ReadOnlyAccessors >::RealScalar

Scalar

template<typename Derived >

typedef internal::traits<Derived>::Scalar Eigen::MapBase< Derived, ReadOnlyAccessors >::Scalar

StorageKind

template<typename Derived >

typedef internal::traits<Derived>::StorageKind Eigen::MapBase< Derived, ReadOnlyAccessors >::StorageKind

Member Enumeration Documentation

anonymous enum

template<typename Derived >

anonymous enum

Enumerator
RowsAtCompileTime
ColsAtCompileTime
InnerStrideAtCompileTime
SizeAtCompileTime

       {
    RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
    ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
    InnerStrideAtCompileTime = internal::traits<Derived>::InnerStrideAtCompileTime,
    SizeAtCompileTime = Base::SizeAtCompileTime
  };

Constructor & Destructor Documentation

MapBase() [1/3]

template<typename Derived >

EIGEN_DEVICE_FUNC Eigen::MapBase< Derived, ReadOnlyAccessors >::MapBase ( PointerType  dataPtr )

inlineexplicit

Constructor for fixed size matrices or vectors

      : m_data(dataPtr), m_rows(RowsAtCompileTime), m_cols(ColsAtCompileTime) {
    EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived)
    checkSanity<Derived>();
  }

References EIGEN_STATIC_ASSERT_FIXED_SIZE.

MapBase() [2/3]

template<typename Derived >

EIGEN_DEVICE_FUNC Eigen::MapBase< Derived, ReadOnlyAccessors >::MapBase ( PointerType  dataPtr, Index  vecSize  )

inline

Constructor for dynamically sized vectors

      : m_data(dataPtr),
        m_rows(RowsAtCompileTime == Dynamic ? vecSize : Index(RowsAtCompileTime)),
        m_cols(ColsAtCompileTime == Dynamic ? vecSize : Index(ColsAtCompileTime)) {
    EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
    eigen_assert(vecSize >= 0);
    eigen_assert(dataPtr == 0 || SizeAtCompileTime == Dynamic || SizeAtCompileTime == vecSize);
    checkSanity<Derived>();
  }

References Eigen::Dynamic, eigen_assert, and EIGEN_STATIC_ASSERT_VECTOR_ONLY.

MapBase() [3/3]

template<typename Derived >

EIGEN_DEVICE_FUNC Eigen::MapBase< Derived, ReadOnlyAccessors >::MapBase ( PointerType  dataPtr, Index  rows, Index  cols  )

inline

Constructor for dynamically sized matrices

      : m_data(dataPtr), m_rows(rows), m_cols(cols) {
    eigen_assert((dataPtr == 0) || (rows >= 0 && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == rows) &&
                                    cols >= 0 && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == cols)));
    checkSanity<Derived>();
  }

References cols, Eigen::Dynamic, eigen_assert, and rows.

Member Function Documentation

checkSanity() [1/2]

template<typename Derived >

template<typename T >

EIGEN_DEVICE_FUNC void Eigen::MapBase< Derived, ReadOnlyAccessors >::checkSanity ( std::enable_if_t< internal::traits< T >::Alignment==0, void * >  = 0 ) const

inlineprotected

                                                                                                       {
#ifndef EIGEN_ALLOW_UNALIGNED_SCALARS
    // Pointer must be aligned to the Scalar type, otherwise we get UB.
    eigen_assert((std::uintptr_t(m_data) % alignof(Scalar) == 0) && "data is not scalar-aligned");
#endif
  }

References eigen_assert.

checkSanity() [2/2]

template<typename Derived >

template<typename T >

EIGEN_DEVICE_FUNC void Eigen::MapBase< Derived, ReadOnlyAccessors >::checkSanity ( std::enable_if_t<(internal::traits< T >::Alignment > 0), void * >  = 0 ) const

inlineprotected

                                                                                                        {
// Temporary macro to allow scalars to not be properly aligned.  This is while we sort out failures
// in TensorFlow Lite that are currently relying on this UB.
#ifndef EIGEN_ALLOW_UNALIGNED_SCALARS
    // Pointer must be aligned to the Scalar type, otherwise we get UB.
    eigen_assert((std::uintptr_t(m_data) % alignof(Scalar) == 0) && "data is not scalar-aligned");
#endif
#if EIGEN_MAX_ALIGN_BYTES > 0
    // innerStride() is not set yet when this function is called, so we optimistically assume the lowest plausible
    // value:
    const Index minInnerStride = InnerStrideAtCompileTime == Dynamic ? 1 : Index(InnerStrideAtCompileTime);
    EIGEN_ONLY_USED_FOR_DEBUG(minInnerStride);
    eigen_assert((((std::uintptr_t(m_data) % internal::traits<Derived>::Alignment) == 0) ||
                  (cols() * rows() * minInnerStride * sizeof(Scalar)) < internal::traits<Derived>::Alignment) &&
                 "data is not aligned");
#endif
  }

References cols, Eigen::Dynamic, eigen_assert, EIGEN_ONLY_USED_FOR_DEBUG, and rows.

coeff() [1/2]

template<typename Derived >

EIGEN_DEVICE_FUNC const Scalar& Eigen::MapBase< Derived, ReadOnlyAccessors >::coeff ( Index  index ) const

inline

This is an overloaded version of DenseCoeffsBase<Derived,ReadOnlyAccessors>::coeff(Index) const provided to by-pass the creation of an evaluator of the expression, thus saving compilation efforts.

See DenseCoeffsBase<Derived,ReadOnlyAccessors>::coeff(Index) const for details.

                                                                  {
    EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
    return m_data[index * innerStride()];
  }

References EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS.

coeff() [2/2]

template<typename Derived >

EIGEN_DEVICE_FUNC const Scalar& Eigen::MapBase< Derived, ReadOnlyAccessors >::coeff ( Index  rowId, Index  colId  ) const

inline

This is an overloaded version of DenseCoeffsBase<Derived,ReadOnlyAccessors>::coeff(Index,Index) const provided to by-pass the creation of an evaluator of the expression, thus saving compilation efforts.

See DenseCoeffsBase<Derived,ReadOnlyAccessors>::coeff(Index) const for details.

                                                                               {
    return m_data[colId * colStride() + rowId * rowStride()];
  }

coeffRef() [1/2]

template<typename Derived >

EIGEN_DEVICE_FUNC const Scalar& Eigen::MapBase< Derived, ReadOnlyAccessors >::coeffRef ( Index  index ) const

inline

This is the const version of coeffRef(Index) which is thus synonym of coeff(Index). It is provided for convenience.

                                                                     {
    EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
    return this->m_data[index * innerStride()];
  }

References EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS.

coeffRef() [2/2]

template<typename Derived >

EIGEN_DEVICE_FUNC const Scalar& Eigen::MapBase< Derived, ReadOnlyAccessors >::coeffRef ( Index  rowId, Index  colId  ) const

inline

This is the const version of coeffRef(Index,Index) which is thus synonym of coeff(Index,Index). It is provided for convenience.

                                                                                  {
    return this->m_data[colId * colStride() + rowId * rowStride()];
  }

cols()

template<typename Derived >

EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index Eigen::MapBase< Derived, ReadOnlyAccessors >::cols ( ) const

inline

{ return m_cols.value(); }

Referenced by gdb.printers._MatrixEntryIterator::__next__(), gdb.printers.EigenMatrixPrinter::children(), gdb.printers.EigenSparseMatrixPrinter::children(), gdb.printers.EigenMatrixPrinter::to_string(), and gdb.printers.EigenSparseMatrixPrinter::to_string().

data()

template<typename Derived >

constexpr EIGEN_DEVICE_FUNC const Scalar* Eigen::MapBase< Derived, ReadOnlyAccessors >::data ( ) const

inlineconstexpr

Returns a pointer to the first coefficient of the matrix or vector.

Note

When addressing this data, make sure to honor the strides returned by innerStride() and outerStride().

See also

innerStride(), outerStride()

{ return m_data; }

Referenced by gdb.printers.EigenMatrixPrinter::children(), gdb.printers.EigenSparseMatrixPrinter::children(), gdb.printers.EigenQuaternionPrinter::children(), gdb.printers.EigenMatrixPrinter::to_string(), gdb.printers.EigenSparseMatrixPrinter::to_string(), and gdb.printers.EigenQuaternionPrinter::to_string().

packet() [1/2]

template<typename Derived >

template<int LoadMode>

PacketScalar Eigen::MapBase< Derived, ReadOnlyAccessors >::packet ( Index  index ) const

inline

                                                {
    EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
    return internal::ploadt<PacketScalar, LoadMode>(m_data + index * innerStride());
  }

References EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS.

packet() [2/2]

template<typename Derived >

template<int LoadMode>

PacketScalar Eigen::MapBase< Derived, ReadOnlyAccessors >::packet ( Index  rowId, Index  colId  ) const

inline

                                                             {
    return internal::ploadt<PacketScalar, LoadMode>(m_data + (colId * colStride() + rowId * rowStride()));
  }

rows()

template<typename Derived >

EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index Eigen::MapBase< Derived, ReadOnlyAccessors >::rows ( ) const

inline

{ return m_rows.value(); }

Referenced by gdb.printers._MatrixEntryIterator::__next__(), gdb.printers.EigenMatrixPrinter::children(), gdb.printers.EigenSparseMatrixPrinter::children(), gdb.printers.EigenMatrixPrinter::to_string(), and gdb.printers.EigenSparseMatrixPrinter::to_string().

Member Data Documentation

m_cols

template<typename Derived >

const internal::variable_if_dynamic<Index, ColsAtCompileTime> Eigen::MapBase< Derived, ReadOnlyAccessors >::m_cols

protected

m_data

template<typename Derived >

PointerType Eigen::MapBase< Derived, ReadOnlyAccessors >::m_data

protected

m_rows

template<typename Derived >

const internal::variable_if_dynamic<Index, RowsAtCompileTime> Eigen::MapBase< Derived, ReadOnlyAccessors >::m_rows

protected

---

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

• MapBase.h