C ++特征库：转换为固定大小的矩阵

Question

following problem:

template<int nDim>
void foo ( ){

    Eigen::Matrix<double, nDim, nDim> bar;

    if ( nDim == 3 ){
        bar = generate_a_special_3x3_Matrix();}
    else if ( nDim == 2 ){
        bar = generate_a_special_2x2_Matrix();}


// ... further math here 
}

So, of course due to the static assertions, this code does not compile. However, it is guaranteed that at runtime never a problem occurs.

Currently know solutions are assignments via .block(3,3) or via Ref<..> (cf. Cast dynamic matrix to fixed matrix in Eigen ).

.block approach:

template<int nDim>
void foo ( ){

    Eigen::Matrix<double, nDim, nDim> bar;

    if ( nDim == 3 ){
        bar.block(3,3) = generate_a_special_3x3_Matrix();}
    else if ( nDim == 2 ){
        bar.block(2,2)  = generate_a_special_2x2_Matrix();}


// ... further math here 
}

However, both approaches involve runtime checks for correct matrix sizes, which are not really necessary, and the written code is not really beautiful.

I don't really care about the runtime overhead (although it would be nice to avoid it), but the written code is not really clean in my eyes, since the intention of .block() is not immediately clear to someone else. Is there a better approach, eg something like a cast?

Edit: Two good solutions were posted (if constexpr), However, i need a C++11/14 compatible approach!

Answer 1

You can use constexpr if from C++17, according to the value of condition, if the value is true , then statement-false is discarded (if present), otherwise, statement-true is discarded; then the code won't cause compilation error. eg

template<int nDim>
void foo () {

    Eigen::Matrix<double, nDim, nDim> bar;

    if constexpr ( nDim == 3 ) {
        bar = generate_a_special_3x3_Matrix();
    } else constexpr if ( nDim == 2 ) {
        bar = generate_a_special_2x2_Matrix();
    }

    // ... further math here 
}

or make a generate_a_special_Matrix function template, eg

template <int nDim>
Eigen::Matrix<double, nDim, nDim> generate_a_special_Matrix();

template <>
Eigen::Matrix<double, 2, 2> generate_a_special_Matrix<2>() { 
    ... generating ...
    return ...; 
}

template <>
Eigen::Matrix<double, 3, 3> generate_a_special_Matrix<3>() { 
    ... generating ...
    return ...; 
}

then

template<int nDim>
void foo () {

    Eigen::Matrix<double, nDim, nDim> bar;
    bar = generate_a_special_Matrix<nDim>();

    // ... further math here 
}

Answer 2

If you are using C++17, you can write

if constexpr ( nDim == 3 ){ bar = generate_a_special_3x3_Matrix();}

etc. But you can easily implement a C++03 compatible solution by templatizing your generate_a_special_nxn_Matrix function:

// general declaration (without implementation):
template<int nDim>
Eigen::Matrix<double, nDim, nDim> generate_a_special_nxn_Matrix();
template<>
Eigen::Matrix<double, 2, 2> generate_a_special_nxn_Matrix(){
    return generate_a_special_2x2_Matrix();
}
template<>
Eigen::Matrix<double, 3, 3> generate_a_special_nxn_Matrix(){
    return generate_a_special_3x3_Matrix();
}

And then directly call

template<int nDim>
void foo ( ){

    Eigen::Matrix<double, nDim, nDim> bar = generate_a_special_nxn_Matrix<nDim>();

    // ... further math here 
}

Answer 3

To elegantly stick with c++98, you can abuse the comma initializer syntax:

template<int N>
void foo(){
  Eigen::Matrix<double, N, N> bar;
  if(N==3)      bar << Matrix3d();
  else if(N==2) bar << Matrix2d();
}