Eigen
3.3.71

This page explains how to work with "raw" C/C++ arrays. This can be useful in a variety of contexts, particularly when "importing" vectors and matrices from other libraries into Eigen.
Occasionally you may have a predefined array of numbers that you want to use within Eigen as a vector or matrix. While one option is to make a copy of the data, most commonly you probably want to reuse this memory as an Eigen type. Fortunately, this is very easy with the Map class.
A Map object has a type defined by its Eigen equivalent:
Note that, in this default case, a Map requires just a single template parameter.
To construct a Map variable, you need two other pieces of information: a pointer to the region of memory defining the array of coefficients, and the desired shape of the matrix or vector. For example, to define a matrix of float
with sizes determined at compile time, you might do the following:
where pf
is a float
*
pointing to the array of memory. A fixedsize readonly vector of integers might be declared as
where pi
is an int
*
. In this case the size does not have to be passed to the constructor, because it is already specified by the Matrix/Array type.
Note that Map does not have a default constructor; you must pass a pointer to intialize the object. However, you can work around this requirement (see Changing the mapped array).
Map is flexible enough to accomodate a variety of different data representations. There are two other (optional) template parameters:
MapOptions
specifies whether the pointer is Aligned
, or Unaligned
. The default is Unaligned
. StrideType
allows you to specify a custom layout for the memory array, using the Stride class. One example would be to specify that the data array is organized in rowmajor format: Example:  Output: 

int array[8];
for(int i = 0; i < 8; ++i) array[i] = i;
cout << "Columnmajor:\n" << Map<Matrix<int,2,4> >(array) << endl;
cout << "Rowmajor:\n" << Map<Matrix<int,2,4,RowMajor> >(array) << endl;
cout << "Rowmajor using stride:\n" <<
Map<Matrix<int,2,4>, Unaligned, Stride<1,4> >(array) << endl;
 Columnmajor: 0 2 4 6 1 3 5 7 Rowmajor: 0 1 2 3 4 5 6 7 Rowmajor using stride: 0 1 2 3 4 5 6 7 
You can use a Map object just like any other Eigen type:
Example:  Output: 

typedef Matrix<float,1,Dynamic> MatrixType;
typedef Map<MatrixType> MapType;
typedef Map<const MatrixType> MapTypeConst; // a readonly map
const int n_dims = 5;
MatrixType m1(n_dims), m2(n_dims);
m1.setRandom();
m2.setRandom();
float *p = &m2(0); // get the address storing the data for m2
MapType m2map(p,m2.size()); // m2map shares data with m2
MapTypeConst m2mapconst(p,m2.size()); // a readonly accessor for m2
cout << "m1: " << m1 << endl;
cout << "m2: " << m2 << endl;
cout << "Squared euclidean distance: " << (m1m2).squaredNorm() << endl;
cout << "Squared euclidean distance, using map: " <<
(m1m2map).squaredNorm() << endl;
m2map(3) = 7; // this will change m2, since they share the same array
cout << "Updated m2: " << m2 << endl;
cout << "m2 coefficient 2, constant accessor: " << m2mapconst(2) << endl;
/* m2mapconst(2) = 5; */ // this yields a compiletime error
 m1: 0.68 0.211 0.566 0.597 0.823 m2: 0.605 0.33 0.536 0.444 0.108 Squared euclidean distance: 3.26 Squared euclidean distance, using map: 3.26 Updated m2: 0.605 0.33 0.536 7 0.108 m2 coefficient 2, constant accessor: 0.536 
All Eigen functions are written to accept Map objects just like other Eigen types. However, when writing your own functions taking Eigen types, this does not happen automatically: a Map type is not identical to its Dense equivalent. See Writing Functions Taking Eigen Types as Parameters for details.
It is possible to change the array of a Map object after declaration, using the C++ "placement new" syntax:
Example:  Output: 

int data[] = {1,2,3,4,5,6,7,8,9};
Map<RowVectorXi> v(data,4);
cout << "The mapped vector v is: " << v << "\n";
new (&v) Map<RowVectorXi>(data+4,5);
cout << "Now v is: " << v << "\n";
 The mapped vector v is: 1 2 3 4 Now v is: 5 6 7 8 9 
Despite appearances, this does not invoke the memory allocator, because the syntax specifies the location for storing the result.
This syntax makes it possible to declare a Map object without first knowing the mapped array's location in memory: