Question

I’m working on something that loops over a potentially multi-dimensional array and I am running into some template issues. Here is the idea of what I’m trying to do:

template<std::size_t D = 3>
class Deriv {
public:
    typedef typename boost::array<double, D> results_t;

    template<typename Iterator>
    results_t operator()(Iterator& objIterator)
    {
        double u;
        double um1;

        results_t derivs;

        for(results_t::index i = 0; i < D; ++i) {
           u = *objIterator;
           um1 = *(objIterator.left<i>(1));
           derivs[i] = u-um1;
        }
     }
   };
};

So, it looks a little confusing, but it’s using a custom iterator that has a left and right template method where the template parameter is the dimension to move left or right in and the argument is the offset. For example, if objIterator points to array[i][j][k], then objIterator.left<0>(1) returns an iterator to array[i-1][j][k].

Obviously what I posted doesn’t work because i is not compile time and can’t be used as the parameter for left. I feel like recursion could be used here somehow to make this happen by replacing that for loop, but I don’t know how.

Any suggestions?

Answer 1

Here’s another approach:

template<std::size_t D = 3>
struct Deriv
{
    typedef typename boost::array<double, D> results_t;

private:
    template<std::size_t I>
    struct apply
    {
        template<typename Iterator>
        static void impl(results_t& derivs, Iterator& iter)
        {
            derivs[I] = *iter - *iter.template left<I>(1);
            apply<I + 1>::impl(derivs, iter);
        }
    };

    template<>
    struct apply<D>
    {
        template<typename Iterator>
        static void impl(results_t&, Iterator&) { }
    };

public:
    template<typename Iterator>
    results_t operator ()(Iterator& iter) const
    {
        results_t derivs;
        apply<0>::impl(derivs, iter);
        return derivs;
    }
};

I’ve tested with VC++ 2010, but I suspect it may not compile on more conformant compilers. If you can count down from D-1 through 0 rather than up from 0 through D-1, then the following should be okay:

namespace detail
{
    template<std::size_t I>
    struct apply
    {
        template<typename ResultsT, typename Iterator>
        static void impl(ResultsT& derivs, Iterator& iter)
        {
            derivs[I] = *iter - *iter.template left<I>(1);
            apply<I - 1>::impl(derivs, iter);
        }
    };

    template<>
    struct apply<0>
    {
        template<typename ResultsT, typename Iterator>
        static void impl(ResultsT& derivs, Iterator& iter)
        {
            derivs[0] = *iter - *iter.template left<0>(1);
        }
    };
}

template<std::size_t D = 3>
struct Deriv
{
    typedef typename boost::array<double, D> results_t;

public:
    template<typename Iterator>
    results_t operator ()(Iterator& iter) const
    {
        results_t derivs;
        detail::apply<D - 1>::impl(derivs, iter);
        return derivs;
    }
};