使用犰狳库进行意外的（错误的）模板推导

Question

I am writing a c++ template function, aimed at computing a function of a matrix, where the matrix type is a template parameter. When using it with the armadillo library, I get an unexpected failure in compilation. I am using armadillo 8.300 and gcc 7.2.0. In the following a test program which illustrates the issue.

#include <armadillo>

arma::Mat<double> sq(const arma::Mat<double>& M)
{
  arma::Mat<double> res(M);
  res = res * M;
  return res;
}

template <class MatrixClass>
MatrixClass sqgen(const MatrixClass& M)
{
  MatrixClass res(M);
  res = res * M;
  return res;
}

int main()
{
  arma::Mat<double> id(3, 3, arma::fill::eye);
  arma::Mat<double> m(3, 3, arma::fill::ones);

  arma::Mat<double> m2(sq(m));
  arma::Mat<double> m_id2(sq(id - m));

  arma::Mat<double> m2gen(sqgen(m));
  arma::Mat<double> m_id2gen(sqgen(id - m)); // Error here
  return 0;
}

For illustration I defined two functions sq and sqgen which essentially do the same job. sq is the explicit instantiation of sqgen when the template parameter MatrixClass is arma::Mat<double> . The compilation with

g++ -std=c++14 -Wall -pedantic -O3 -o test test.cpp -lstdc++ -larmadillo

fails giving the error:

test.cpp: In instantiation of ‘MatrixClass sq(const MatrixClass&) [with MatrixClass = arma::eGlue<arma::Mat<double>, arma::Mat<double>, arma::eglue_minus>]’:
test.cpp:24:36:   required from here
test.cpp:14:7: error: no match for ‘operator=’ (operand types are ‘arma::eGlue<arma::Mat<double>, arma::Mat<double>, arma::eglue_minus>’ and ‘arma::enable_if2<true, const arma::Glue<arma::eGlue<arma::Mat<double>, arma::Mat<double>, arma::eglue_minus>, arma::eGlue<arma::Mat<double>, arma::Mat<double>, arma::eglue_minus>, arma::glue_times> >::result {aka const arma::Glue<arma::eGlue<arma::Mat<double>, arma::Mat<double>, arma::eglue_minus>, arma::eGlue<arma::Mat<double>, arma::Mat<double>, arma::eglue_minus>, arma::glue_times>}’)
   res = res * M;
   ~~~~^~~~~~~~~
In file included from /usr/include/armadillo:204:0,
                 from test.cpp:1:
/usr/include/armadillo_bits/eGlue_bones.hpp:22:7: note: candidate: arma::eGlue<arma::Mat<double>, arma::Mat<double>, arma::eglue_minus>& arma::eGlue<arma::Mat<double>, arma::Mat<double>, arma::eglue_minus>::operator=(const arma::eGlue<arma::Mat<double>, arma::Mat<double>, arma::eglue_minus>&) <deleted>
 class eGlue : public Base<typename T1::elem_type, eGlue<T1, T2, eglue_type> >
       ^~~~~
/usr/include/armadillo_bits/eGlue_bones.hpp:22:7: note:   no known conversion for argument 1 from ‘arma::enable_if2<true, const arma::Glue<arma::eGlue<arma::Mat<double>, arma::Mat<double>, arma::eglue_minus>, arma::eGlue<arma::Mat<double>, arma::Mat<double>, arma::eglue_minus>, arma::glue_times> >::result {aka const arma::Glue<arma::eGlue<arma::Mat<double>, arma::Mat<double>, arma::eglue_minus>, arma::eGlue<arma::Mat<double>, arma::Mat<double>, arma::eglue_minus>, arma::glue_times>}’ to ‘const arma::eGlue<arma::Mat<double>, arma::Mat<double>, arma::eglue_minus>&’

The problem lies in the last call of sqgen . There is no problem in calling sqgen(m) , however the call sqgen(id - m) causes the error. Notice that, instead, using the call sq(id - m) is perfectly legal. Since the function sqgen should be, in the code above, exactly equal to sq , I presume that the compiler does not deduce correctly the template parameter MatrixClass in sqgen(id - m) . In fact, upon substituting

arma::Mat<double> m_id2gen(sqgen(id - m));

with

arma::Mat<double> m_id2gen(sqgen(arma::Mat<double>(id - m)));

the code compiles correctly.

Answer 1

Template pattern matching matches exact types (and types of parent types if the exact type doesn't match).

Overload resolution matches exact types, parent types, and types that can be converted to.

Odds are that arma::Mat 's operations result in expression templates, which can be converted into matrices, but are not themselves matrices. They exist so that you can take an entire line of matrix math, and efficiently not do it until you actually convert everything into a matrix.

Because sqgen takes an anything, in this case it tries to consume an expression template whose value is the difference between two matrices.

You then create a temporary expression template instance with no arguments, multiply it with another expression template, assign to it, and return it. None of these make sense for an expression template.

This is a known problem with expression templates and generic code. Typically there are ways to force evaluation of expression templates. Assinging them to a matrix does it (and is how sq works), casting them works, and in this case there is a .eval() member function which does it without having to name the type.

So, try

arma::Mat<double> m_id2gen(sqgen((id - m).eval()));

Answer 2

The compiler is working fine. Armadillo does heavy optimization of expressions involving matrices, such as reordering multiplications, delaying evaluation, and more. This is all done via template metaprogramming. The Armadillo matrix classes provide copy-assignment operators (eg, mat::operator=() ), which take other matrices and copy their data. There is, however, no overload of the operator=() which takes one of these expression templates. Hence the error about operand types are 'eGlue<...>...' and such.

The quick fix to this is to add .eval() to the end of any expression, which forces evaluation of said expression. So you'd do:

res = (res * M).eval();
return res;

Or just:

return (res * M).eval(); // I'm actually not sure if the eval() is necessary here.

Another option is to try doing in-place multiplication, which should also work fine. As in:

res *= M;
return res;