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

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.

Contents

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 maniputate 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>
using namespace Eigen;
using namespace std;

template<typename Derived>
Eigen::Block<Derived>
topLeftCorner(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 MatrixBase<Derived>& m, int rows, int cols)
{
  return Eigen::Block<const Derived>(m.derived(), 0, 0, rows, cols);
}

int main(int, char**)
{
  Matrix4d m = Matrix4d::Identity();
  cout << topLeftCorner(4*m, 2, 3) << endl; // calls the const version
  topLeftCorner(m, 2, 3) *= 5;              // calls the non-const version
  cout << "Now the matrix m is:" << endl << m << endl;
  return 0;
}

Output:

4 0 0
0 4 0
Now the matrix m is:
5 0 0 0
0 5 0 0
0 0 1 0
0 0 0 1

Here is an example illustrating the fixed-size case:

#include <Eigen/Core>
#include <iostream>
using namespace Eigen;
using namespace std;

template<typename Derived>
Eigen::Block<Derived, 2, 2>
topLeft2x2Corner(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 MatrixBase<Derived>& m)
{
  return Eigen::Block<const Derived, 2, 2>(m.derived(), 0, 0);
}

int main(int, char**)
{
  Matrix3d m = Matrix3d::Identity();
  cout << topLeft2x2Corner(4*m) << endl; // calls the const version
  topLeft2x2Corner(m) *= 2;              // calls the non-const version
  cout << "Now the matrix m is:" << endl << m << endl;
  return 0;
}

Output:

4 0
0 4
Now the matrix m is:
2 0 0
0 2 0
0 0 1

Constructors, destructors, conversion operators

Block(XprType& xpr, Index i)
Block(XprType& xpr, Index startRow, Index startCol)
Block(XprType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)

Function documentation

template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
Eigen::Block<XprType, BlockRows, BlockCols, InnerPanel>::Block(XprType& xpr, Index i)

Column or Row constructor

template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
Eigen::Block<XprType, BlockRows, BlockCols, InnerPanel>::Block(XprType& xpr, Index startRow, Index startCol)

Fixed-size constructor

template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
Eigen::Block<XprType, BlockRows, BlockCols, InnerPanel>::Block(XprType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)

Dynamic-size constructor