带Armadillo的C ++中的函数模板

Question

I am writing some function templates using armadillo linear algebra library, but it encounters some errors. I am still learning C++ and its aspects, so will be very much thankful for any possible solutions. Most of my functions are like the following,

template<typename T1>
void some_function(const Mat<T1> & p)
{
    unsigned int n = p.n_rows;
    // do some stuffs...
    // ....
}

My main function contains:

Mat<double> A = ones<Mat<double>>(4,4);
int a(2);
some_function(A);  // runs perfectly
some_function(a*A); // compilation error as follows

test_function.hpp:35:8: note: template argument deduction/substitution failed:
test.cpp:22:17: note: ‘arma::enable_if2<true, const arma::eOp<arma::Mat<double>, arma::eop_scalar_times> >::result {aka const arma::eOp<arma::Mat<double>, arma::eop_scalar_times>}’ is not derived from ‘const arma::Mat<eT>’
some_function(a*A);

If I change the function as follows:

template<typename T1>
void some_function(const T1 & p)
{
    unsigned int n = p.n_rows;
    // do some stuffs...
    // ....
}

Then it gives the compilation error as follows:

test_function.hpp: In instantiation of ‘bool some_function(const T1&) [with T1 = arma::eOp<arma::Mat<double>, arma::eop_scalar_times>]’:
test.cpp:22:17:   required from here
test_function.hpp:37:26: error: ‘const class arma::eOp<arma::Mat<double>, arma::eop_scalar_times>’ has no member named ‘n_rows’
 unsigned int n = p.n_rows;

But the non-template functions work perfectly, like

void some_function(const Mat<double> & p)
{
    unsigned int n = p.n_rows();
    // do some stuffs...
    // ....
}

Any solutions??

Answer 1

Use the .eval() member function to forcefully convert an Armadillo expression into a matrix.

You can then use the result of .eval() as the input to a function. For example:

mat A(10,20,fill::randu);
mat B(10,20,fill::randu);

some_function( (A+B).eval() );

Also note that the Mat class doesn't have a member function called n_rows(). Instead it has a read-only variable called n_rows . For example:

unsigned int n = X.n_rows;

Answer 2

I think that with those helpers:

template <typename T>
const Mat<T>& as_Mat(const Mat<T>& m) {return m;}

template<typename T1, typename eop_type>
Mat<typename T1::elem_type> as_Mat(const eOp<T1, eop_type>& X)
{
    return {X};
}

You may write:

template<typename T>
void some_function(const T & p)
{
    const auto& mat = as_mat(p);
    unsigned int n = mat.n_rows();
    // do some stuffs...
    // ....
}

Answer 3

After Jarod42 's post, I put some time on this matter and found out another possible solution to this problem, very similar to Jarod42 's one. I am replying it as an answer for anyone who might stuck into this same problem like myself. I just changed the second as_Mat function that Jarod42 has already written.

template <typename T>
const Mat<T>& as_Mat(const Mat<T>& m) {return m;}


template<typename T>
Mat<typename T::elem_type> as_Mat(const T& X)
{
    return {X};
}

And all user defined functions will contain one line as before.

template<typename T>
void some_function(const T & X)
{
    const auto& Y = as_Mat(X);
    // do some stuffs with Y...
    // ....
} 

This way any delayed evaluation will be converted into matrix, eg. A+B , A*B , i*A ( i = int, complex<>,double...) etc. etc. etc.

Though I am not sure about the performance of the code and also, as mtall mentioned about .eval() function, this fix can be very much helpful to build templated libraries using Armadillo, where library users do not need to put .eval() every other time. Again, thank you all for your kind help and attention.