Eigen
3.3.90 (mercurial changeset 94875feeeeb9)

This page presents the numerous possibilities offered by operator()
to index subset of rows and columns. This API has been introduced in Eigen 3.4. It supports all the feature proposed by the block API , and much more. In particular, it supports slicing that consists in taking a set of rows, columns, or elements, uniformly spaced within a matrix or indexed from an array of indices.
All the aforementioned operations are handled through the generic DenseBase::operator()(const RowIndices&, const ColIndices&) method. Each argument can be:
int[N]
.More generally, it can accepts any object exposing the following two member functions:
where <integral type>
stands for any integer type compatible with Eigen::Index (i.e. std::ptrdiff_t
).
Taking a set of rows, columns, or elements, uniformly spaced within a matrix or vector is achieved through the Eigen::seq or Eigen::seqN functions where "seq" stands for arithmetic sequence. Their signatures are summarized below:
function  description  example 

seq(firstIdx,lastIdx)  represents the sequence of integers ranging from firstIdx to lastIdx  seq(2,5) <=> {2,3,4,5} 
seq(firstIdx,lastIdx,incr)  same but using the increment incr to advance from one index to the next  seq(2,8,2) <=> {2,4,6,8} 
seqN(firstIdx,size)  represents the sequence of size integers starting from firstIdx  seqN(2,5) <=> {2,3,4,5,6} 
seqN(firstIdx,size,incr)  same but using the increment incr to advance from one index to the next  seqN(2,3,3) <=> {2,5,8} 
The firstIdx
and lastIdx
parameters can also be defined with the help of the Eigen::last symbol representing the index of the last row, column or element of the underlying matrix/vector once the arithmetic sequence is passed to it through operator(). Here are some examples for a 2D array/matrix A
and a 1D array/vector v
.
Intent  Code  BlockAPI equivalence 

Bottomleft corner starting at row i with n columns  A.bottomLeftCorner(A.rows()i,n)  
Block starting at i ,j having m rows, and n columns  A.block(i,j,m,n)  
Block starting at i0 ,j0 and ending at i1 ,j1  A.block(i0,j0,i1i0+1,j1j0+1)  
Even columns of A  
First n odd rows A  
The last past one column  A.col(A.cols()2)  
The middle row  A.row((A.rows()1)/2)  
Last elements of v starting at i  v.tail(v.size()i)  
Last n elements of v  v.tail(n) 
As seen in the last exemple, referencing the last n elements (or rows/columns) is a bit cumbersome to write. This becomes even more tricky and error prone with a nondefault increment. Here comes Eigen::lastN(size) , and Eigen::lastN(size,incr) :
Intent  Code  BlockAPI equivalence 

Last n elements of v  v(lastN(n))  v.tail(n) 
Bottomright corner of A of size m times n  A.bottomRightCorner(m,n)  
Bottomright corner of A of size m times n  A.bottomRightCorner(m,n)  
Last n columns taking 1 column over 3 
In terms of performance, Eigen and the compiler can take advantage of compiletime size and increment. To this end, you can enforce compiletime parameters using Eigen::fix<val>. Such compiletime value can be combined with the Eigen::last symbol:
In this example Eigen knowns at compiletime that the returned expression has 6 elements. It is equivalent to:
We can revisit the even columns of A example as follows:
Row/column indices can also be enumerated in decreasing order using a negative increment. For instance, one over two columns of A from the column 20 to 10:
The last n
rows starting from the last one:
You can also use the ArithmeticSequence::reverse() method to reverse its order. The previous example can thus also be written as:
The generic operator()
can also takes as input an arbitrary list of row or column indices stored as either an ArrayXi
, a std::vector<int>
, std::array<int,N>
, etc.
Example:  Output: 

std::vector<int> ind{4,2,5,5,3}; MatrixXi A = MatrixXi::Random(4,6); cout << "Initial matrix A:\n" << A << "\n\n";  Initial matrix A: 7 9 5 3 3 10 2 6 1 0 5 5 6 3 0 9 8 8 6 6 3 9 2 6 A(all,ind): 3 5 10 10 3 5 1 5 5 0 8 0 8 8 9 2 3 6 6 9 
You can also directly pass a static array:
Example:  Output: 

#if EIGEN_HAS_STATIC_ARRAY_TEMPLATE MatrixXi A = MatrixXi::Random(4,6); cout << "Initial matrix A:\n" << A << "\n\n"; #endif  Initial matrix A: 7 9 5 3 3 10 2 6 1 0 5 5 6 3 0 9 8 8 6 6 3 9 2 6 A(all,{4,2,5,5,3}): 3 5 10 10 3 5 1 5 5 0 8 0 8 8 9 2 3 6 6 9 
or expressions:
Example:  Output: 

ArrayXi ind(5); ind<<4,2,5,5,3; MatrixXi A = MatrixXi::Random(4,6); cout << "Initial matrix A:\n" << A << "\n\n";  Initial matrix A: 7 9 5 3 3 10 2 6 1 0 5 5 6 3 0 9 8 8 6 6 3 9 2 6 A(all,ind1): 3 9 3 3 5 0 6 5 5 1 9 3 8 8 0 9 6 2 2 3 
When passing an object with a compiletime size such as Array4i
, std::array<int,N>
, or a static array, then the returned expression also exhibit compiletime dimensions.
More generally, operator()
can accept as inputs any object ind
of type T
compatible with:
This means you can easily build your own fancy sequence generator and pass it to operator()
. Here is an exemple enlarging a given matrix while padding the additional first rows and columns through repetition:
Example:  Output: 

struct pad { Index in_size, out_size; }; Matrix3i A; A.reshaped() = VectorXi::LinSpaced(9,1,9); cout << "Initial matrix A:\n" << A << "\n\n"; MatrixXi B(5,5); B = A(pad{3,5}, pad{3,5}); cout << "A(pad{3,N}, pad{3,N}):\n" << B << "\n\n";  Initial matrix A: 1 4 7 2 5 8 3 6 9 A(pad{3,N}, pad{3,N}): 1 1 1 4 7 1 1 1 4 7 1 1 1 4 7 2 2 2 5 8 3 3 3 6 9 