Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel > Class Template Reference

Expression of a fixed-size or dynamic-size block. More...

#include <Block.h>

Inheritance diagram for Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel >:

Public Types
typedef Impl	Base
typedef internal::remove_all_t< XprType >	NestedExpression
using	ConstUnwindReturnType = Block< const typename BlockHelper::BaseType, BlockRows, BlockCols, InnerPanel >
using	UnwindReturnType = Block< typename BlockHelper::BaseType, BlockRows, BlockCols, InnerPanel >

Public Member Functions
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE	Block (XprType &xpr, Index i)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE	Block (XprType &xpr, Index startRow, Index startCol)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE	Block (XprType &xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ConstUnwindReturnType	unwind () const
template<typename T = Block, typename EnableIf = std::enable_if_t<!std::is_const<T>::value>>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE UnwindReturnType	unwind ()

Private Types
typedef BlockImpl< XprType, BlockRows, BlockCols, InnerPanel, typename internal::traits< XprType >::StorageKind >	Impl
using	BlockHelper = internal::block_xpr_helper< Block >

Detailed Description

template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
class Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel >

Expression of a fixed-size or dynamic-size block.

Template Parameters

XprType	the type of the expression in which we are taking a block
BlockRows	the number of rows of the block we are taking at compile time (optional)
BlockCols	the number of columns of the block we are taking at compile time (optional)
InnerPanel	is true, if the block maps to a set of rows of a row major matrix or to set of columns of a column major matrix (optional). The parameter allows to determine at compile time whether aligned access is possible on the block expression.

This class represents an expression of either a fixed-size or dynamic-size block. It is the return type of DenseBase::block(Index,Index,Index,Index) and DenseBase::block<int,int>(Index,Index) and most of the time this is the only way it is used.

However, if you want to directly manipulate block expressions, for instance if you want to write a function returning such an expression, you will need to use this class.

Here is an example illustrating the dynamic case:

#include <Eigen/Core>
#include <iostream>
 
template <typename Derived>
Eigen::Block<Derived> topLeftCorner(Eigen::MatrixBase<Derived>& m, int rows, int cols) {
  return Eigen::Block<Derived>(m.derived(), 0, 0, rows, cols);
}
 
template <typename Derived>
const Eigen::Block<const Derived> topLeftCorner(const Eigen::MatrixBase<Derived>& m, int rows, int cols) {
  return Eigen::Block<const Derived>(m.derived(), 0, 0, rows, cols);
}
 
int main(int, char**) {
  Eigen::Matrix4d m = Eigen::Matrix4d::Identity();
  std::cout << topLeftCorner(4 * m, 2, 3) << std::endl;  // calls the const version
  topLeftCorner(m, 2, 3) *= 5;                           // calls the non-const version
  std::cout << "Now the matrix m is:" << std::endl << m << std::endl;
  return 0;
}

Output:

Note

Even though this expression has dynamic size, in the case where XprType has fixed size, this expression inherits a fixed maximal size which means that evaluating it does not cause a dynamic memory allocation.

Here is an example illustrating the fixed-size case:

#include <Eigen/Core>
#include <iostream>
 
template <typename Derived>
Eigen::Block<Derived, 2, 2> topLeft2x2Corner(Eigen::MatrixBase<Derived>& m) {
  return Eigen::Block<Derived, 2, 2>(m.derived(), 0, 0);
}
 
template <typename Derived>
const Eigen::Block<const Derived, 2, 2> topLeft2x2Corner(const Eigen::MatrixBase<Derived>& m) {
  return Eigen::Block<const Derived, 2, 2>(m.derived(), 0, 0);
}
 
int main(int, char**) {
  Eigen::Matrix3d m = Eigen::Matrix3d::Identity();
  std::cout << topLeft2x2Corner(4 * m) << std::endl;  // calls the const version
  topLeft2x2Corner(m) *= 2;                           // calls the non-const version
  std::cout << "Now the matrix m is:" << std::endl << m << std::endl;
  return 0;
}

Output:

See also

DenseBase::block(Index,Index,Index,Index), DenseBase::block(Index,Index), class VectorBlock

Member Typedef Documentation

Base

template<typename XprType , int BlockRows, int BlockCols, bool InnerPanel>

typedef Impl Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel >::Base

BlockHelper

template<typename XprType , int BlockRows, int BlockCols, bool InnerPanel>

using Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel >::BlockHelper = internal::block_xpr_helper<Block>

private

ConstUnwindReturnType

template<typename XprType , int BlockRows, int BlockCols, bool InnerPanel>

using Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel >::ConstUnwindReturnType = Block<const typename BlockHelper::BaseType, BlockRows, BlockCols, InnerPanel>

Impl

template<typename XprType , int BlockRows, int BlockCols, bool InnerPanel>

typedef BlockImpl<XprType, BlockRows, BlockCols, InnerPanel, typename internal::traits<XprType>::StorageKind> Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel >::Impl

private

NestedExpression

template<typename XprType , int BlockRows, int BlockCols, bool InnerPanel>

typedef internal::remove_all_t<XprType> Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel >::NestedExpression

UnwindReturnType

template<typename XprType , int BlockRows, int BlockCols, bool InnerPanel>

using Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel >::UnwindReturnType = Block<typename BlockHelper::BaseType, BlockRows, BlockCols, InnerPanel>

Constructor & Destructor Documentation

Block() [1/3]

template<typename XprType , int BlockRows, int BlockCols, bool InnerPanel>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel >::Block ( XprType &  xpr, Index  i  )

inline

Column or Row constructor

                                                                     : Impl(xpr, i) {
    eigen_assert((i >= 0) && (((BlockRows == 1) && (BlockCols == XprType::ColsAtCompileTime) && i < xpr.rows()) ||
                              ((BlockRows == XprType::RowsAtCompileTime) && (BlockCols == 1) && i < xpr.cols())));
  }

References eigen_assert, and i.

Block() [2/3]

template<typename XprType , int BlockRows, int BlockCols, bool InnerPanel>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel >::Block ( XprType &  xpr, Index  startRow, Index  startCol  )

inline

Fixed-size constructor

      : Impl(xpr, startRow, startCol) {
    EIGEN_STATIC_ASSERT(RowsAtCompileTime != Dynamic && ColsAtCompileTime != Dynamic,
                        THIS_METHOD_IS_ONLY_FOR_FIXED_SIZE)
    eigen_assert(startRow >= 0 && BlockRows >= 0 && startRow + BlockRows <= xpr.rows() && startCol >= 0 &&
                 BlockCols >= 0 && startCol + BlockCols <= xpr.cols());
  }

References Eigen::Dynamic, eigen_assert, and EIGEN_STATIC_ASSERT.

Block() [3/3]

template<typename XprType , int BlockRows, int BlockCols, bool InnerPanel>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel >::Block ( XprType &  xpr, Index  startRow, Index  startCol, Index  blockRows, Index  blockCols  )

inline

Dynamic-size constructor

      : Impl(xpr, startRow, startCol, blockRows, blockCols) {
    eigen_assert((RowsAtCompileTime == Dynamic || RowsAtCompileTime == blockRows) &&
                 (ColsAtCompileTime == Dynamic || ColsAtCompileTime == blockCols));
    eigen_assert(startRow >= 0 && blockRows >= 0 && startRow <= xpr.rows() - blockRows && startCol >= 0 &&
                 blockCols >= 0 && startCol <= xpr.cols() - blockCols);
  }

References Eigen::Dynamic, and eigen_assert.

Member Function Documentation

unwind() [1/2]

template<typename XprType , int BlockRows, int BlockCols, bool InnerPanel>

template<typename T = Block, typename EnableIf = std::enable_if_t<!std::is_const<T>::value>>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE UnwindReturnType Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel >::unwind ( )

inline

                                                                  {
    return UnwindReturnType(BlockHelper::base(*this), BlockHelper::row(*this, 0), BlockHelper::col(*this, 0),
                            this->rows(), this->cols());
  }

References col(), cols, row(), and rows.

unwind() [2/2]

template<typename XprType , int BlockRows, int BlockCols, bool InnerPanel>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ConstUnwindReturnType Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel >::unwind ( ) const

inline

                                                                             {
    return ConstUnwindReturnType(BlockHelper::base(*this), BlockHelper::row(*this, 0), BlockHelper::col(*this, 0),
                                 this->rows(), this->cols());
  }

References col(), cols, row(), and rows.

Referenced by unwind_test_impl< BaseXpr, Xpr, Depth >::run().

---

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

• Block.h