Building Compile-Time Matrix Expressions - c++

Question

I've just started using Eigen and have read from their documentation that the best performance comes from their lazy evaluation of matrix expressions. Hence, expressions like this are very efficient once evaluated:
Eigen::Matrix<float, 3, 1> a;
a << 0, 1, 2;
Eigen::Matrix<float, 3, 1> b;
b << 3, 4, 5;
Eigen::Matrix<float, 3, 1> c;
c << (a + b).sum(),
(a - b).sum(),
a.sum();
std::cout << c << std::endl;
I ran into a problem when constructing matrices whose column count depends on a template parameter. For example:
template <std::size_t w>
auto buildGradient() {
Eigen::Matrix<float, 3, w> matrix;
matrix << /* ? */;
return matrix;
}
My first inclination was to use a recursive c++ template do do this.
template <std::size_t w, typename Functor>
auto buildGradientExpr(Functor functor) {
if constexpr (w == 0) {
return;
} else if constexpr (w == 1) {
return functor();
} else {
return functor(), buildGradientExpr<w - 1, Functor>(functor);
}
}
But using this leads to runtime errors issued by Eigen, since the expression only has one initializer.
template <std::size_t w>
auto buildGradient() {
Eigen::Matrix<float, 3, w> gradient;
/* Emits an error about too few coefficients being passed to the initializer. */
gradient << buildGradientExpr<w>([]() { /* Return 3x1 matrix */ });
return gradient;
}
Here's a complete runnable example.
#include <Eigen/Dense>
#include <iostream>
#include <cstddef>
namespace {
template <std::size_t w, typename Functor>
auto buildGradientExpr(Functor functor) {
if constexpr (w == 0) {
return;
} else if constexpr (w == 1) {
return functor(w);
} else {
return functor(w), buildGradientExpr<w - 1, Functor>(functor);
}
}
template <std::size_t w, typename Functor>
auto buildGradient(Functor functor) {
Eigen::Matrix<float, 3, w> gradient;
gradient << buildGradientExpr<w>(functor);
return gradient;
}
} // namespace
int main() {
constexpr std::size_t gradient_width = 10;
auto gradient_functor = [](std::size_t w) {
return Eigen::Matrix<float, 3, 1>::Constant(float(w) / gradient_width);
};
auto gradient = buildGradient<gradient_width>(gradient_functor);
std::cout << gradient << std::endl;
return 0;
}
Is there a way of constructing matrices with sizes that depend on template parameters, without resorting to a for loop? Nothing against for loops, that's what I'm using in the mean time. I'd just like to know if there's a way to initialize a matrix expression using template loops.
Edit:* I updated the example, because the gradient functor was suppose to be returning a vector and not a scalar. The sample problem occurs, though.

Answer 1

If I understand correctly your issue here, and you can use c++11, a possible solution could be the following:
(a) extend the Eigen::Matrix class as explained here to include the constructor from std::initializer_list<T>:
// File "Eigen_plugin.h"
template<class T>
Matrix(std::initializer_list<T> elems) : Base()
{
Base::_check_template_params();
int idx = 0;
for(auto el : elems)
coeffRef(idx++) = el;
}
(b) define your buildGradient function using variadic templates:
// File main.cpp
#include <iostream>
#include <eigen3/Eigen/Dense>
template<class... Args>
Eigen::Matrix<double, 3, sizeof...(Args)/3> buildGradient(Args&&... args)
{
static_assert(sizeof...(Args) % 3 == 0, "Wrong number of elements");
return Eigen::Matrix<double, 3, sizeof...(Args)/3>{ args... };
}
int main()
{
std::cout << buildGradient(1.0,2.0,3.0) << std::endl;
std::cout << buildGradient(1.0,2.0,3.0,4.0,5.0,6.0) << std::endl;
}
Note
As explained in the first link, to make this compile you need to define the preprocessor variable EIGEN_MATRIX_PLUGIN to point at the absolute path of your plugin file:
g++ -std=c++11 main.cpp -D EIGEN_MATRIX_PLUGIN=\"path-to-Eigen_plugin.h\"