ansaurus

Question

Templated Matrix Class Not Generating Functions Correctly

Answer 1

+4 A:

Matrix::minor(0, j) returns a matrix of size (N-1, N-1). Calling for its determinant makes the process recursive, which means you are generating a minor (and determinant method) for all p integers, starting from N down to ... -infinity ?

Have you added a specialization for the case where N==1 or N==0 ? You have to make sure recursion stops !

Try adding something like :

template<>
struct Matrix<1,1>
{
  float values[1][1];

  float determinant(){ return values[0][0]; }
};

EDIT : Recursion has to be stopped at compile time. Adding an if statement inside the method does not prevent the compiler from compiling all possible paths.

Benoît 2010-08-19 09:30:52

Thanks! It works! Just a small typo in your code though -- `int float` should simply be `float` :)

rfw 2010-08-19 09:32:21

@rfw: That's a dynamic-time branch, you need a static-time branch. Add a specialization for a 0 sized matrix.

GMan 2010-08-19 09:37:15

Answer 2

A:

I agree with "Benoît"

The even fact that during the runtime you never call minor function on an 'empty' matrix - doesn't prevent the compiler from generating that code.

To avoid this you should play with explicit template specializations. So that even at compile time the compiler won't encounter program paths that lead to infinite template function generation.

Like this one:

template <int N>
float determinantInternal()
{
    // Standard algoritm for NxN matrix
    float det = 0;
    for(int j = 0; j < TCols; ++j)
        det += (j % 2 ? -1 : 1) * this->values[0][j] * this->minor(0, j).determinant();

    return det;
}

template <>
float determinantInternal<0>()
{
    return 0;
}

float determinantInternal<1>()
{
    return this->values[0][0];
}

float determinantInternal<2>()
{
    return this->values[0][0] * this->values[1][1] - this->values[1][0] * this->values[0][1];
}

template <>
float determinant()
{
    if (TRows != TCols)
        throw DimensionError("Matrix is not square");
    // Alternatively you can use something to prevent this from compiling. 
    // This way you produce the compile-time error if attempted to call
    // determinant on a non-square matrix
    BOOST_STATIC_ASSERT(TRows == TCols);

    return determinantInternal<TRows>();
}

One more advantage of this type of specialization is that you handle different matrix types (empty, non-square, 1x1, NxN) at compile time. Hence you get a bit faster code.

Plus you can prevent calling determinant on non-square matrixes. In such a case you'll get a compiler/linker error when attempting to do it, rather than exception at run-time.

valdo 2010-08-19 10:53:05

ansaurus

tags:

views:

answers:

Templated Matrix Class Not Generating Functions Correctly

related questions