Static for cycle - c++

Question

I am writing templated short vector and small matrix classes, that are not restricted to having 2-3-4 elements, but can have an arbitrary number of elements.
template <typename T, size_t N>
class ShortVector
{
public:
...
template <size_t I> T& get() { return m_data[I]; }
template <size_t I> const T& get() const { return m_data[I]; }
private:
T m_data[N];
};
I want to have the access interface be static, so that I can specialize the class to use built-in vector registers for the supported sizes of the class. (May them be AVX, C++AMP or OpenCL vectors.) Problem is that writing ALL the desirable operators for this class (unary-, +, -, *, /, dot, length, ...) requires an awful lot of template recursion, and I haven't even gotten to implement matrix-vector and matrix-matrix multiplication, where I will need nested recursion.
Right now I have non-member friend operators and a private member class with various static functions such as
template <size_t I, typename T1, typename T2> struct Helpers
{
static void add(ShortVector& dst, const ShortVector<T1, N>& lhs, const ShortVector<T2, N>& rhs)
{
dst.get<I>() = lhs.get<I>() + rhs.get<I>();
Helpers<I - 1, T1, T2>::add(dst, lhs, rhs);
}
...
};
template <typename T1, typename T2> struct Helpers < 0, T1, T2 >
{
static void add(ShortVector& dst, const ShortVector<T1, N>& lhs, const ShortVector<T2, N>& rhs)
{
dst.get<0>() = lhs.get<0>() + rhs.get<0>();
}
...
};
Writing static functions and specializations like this for all operators just feels wrong. Writing the more complex operations in this manner is highly error prone. What I'm looking for is something like
static_for< /*Whatever's needed to define something like a run-time for cycle*/, template <size_t I, typename... Args> class Functor>();
Or practically anything that let's me omit the majority of this boilerplate code. I have started writing such a class, but I could not get it to compile with a reasonable specialization. I feel I still lack the skill to write such a class (or function). I have looked at other libs such as Boost MPL, but have not fully committed to using it. I have also looked at std::index_sequence which might also prove useful.
While the std::index_sequence seems like the most portable solution, it has a major flaw I am reluctant to look over. Ultimately these classes must be SYCL compatible, meaning I am restricted to using C++11, including template metaprogramming techniques. std::integer_sequence is a C++14 STL library addition, and while this restriction of language standard only matters in terms of language features, nothing prevents the STL implementer to use C++14 language features while implementing a C++14 STL feature, therefore using C++14 STL features might not be portable.
I am open to suggestions, or even solutions.
EDIT
Here is what I'v come up so far. This is the header of Template Metaprogramming tricks I started to collect, and the for loop would be next in line. The helper needs a functor which has the running index as it's first parameter, and accepts various predicates. It would keep instantiating the functor as long as the predicate for the next iteration holds true. It would be possible to have the running index increment by any number, be multiplied by a number, etc.

Answer 1

You could have a look at Boost Fusion's algorithms.
All that's required is to adapt your type as a Fusion Sequence.
Simple sample: Live On Coliru
#include <boost/array.hpp>
#include <boost/fusion/adapted.hpp>
#include <boost/fusion/algorithm.hpp>
#include <boost/fusion/include/io.hpp>
#include <iostream>
int main()
{
using namespace boost;
boost::array<int, 4> iv4 { 1,2,3,4 };
boost::array<double, 4> id4 { .1, .2, .3, .4 };
auto r = fusion::transform(iv4, id4, [](auto a, auto b) { return a+b; });
std::cout << r;
}
Prints:
(1.1 2.2 3.3 4.4)

Answer 2

What about this:
template <size_t I, typename Functor, typename = std::make_index_sequence<I>>
struct Apply;
template <size_t I, typename Functor, std::size_t... Indices>
struct Apply<I, Functor, std::index_sequence<Indices...>> :
private std::tuple<Functor> // For EBO with functors
{
Apply(Functor f) : std::tuple<Functor>(f) {}
Apply() = default;
template <typename InputRange1, typename InputRange2, typename OutputRange>
void operator()(OutputRange& dst,
const InputRange1& lhs, const InputRange2& rhs) const
{
(void)std::initializer_list<int>
{ (dst.get<Indices>() = std::get<0>(*this)(lhs.get<Indices>(),
rhs.get<Indices>()), 0)... };
}
};
Usage could be
Apply<4,std::plus<>>()(dest, lhs, rhs); // Size or functor type
// can be deduced if desired
A (slightly modified) example: Demo.
You could also remove the functor state if it hinders you in any way:
template <size_t I, typename Functor, typename = std::make_index_sequence<I>>
struct Apply;
template <size_t I, typename Functor, std::size_t... Indices>
struct Apply<I, Functor, std::index_sequence<Indices...>>
{
template <typename InputRange1, typename InputRange2, typename OutputRange>
void operator()(OutputRange& dst,
const InputRange1& lhs, const InputRange2& rhs) const
{
(void)std::initializer_list<int>
{ (dst.get<Indices>() = Functor()(lhs.get<Indices>(),
rhs.get<Indices>()), 0)... };
}
};

Answer 3

Regarding
” I am restricted to using C++11, including template metaprogramming techniques. std::integer_sequence is a C++14 STL library addition […]
… you can do this with e.g. the g++ compiler:
namespace my {
using std::tuple;
using std::tuple_cat;
template< int i >
struct Number_as_type_ {};
template< int... values >
using Int_sequence_ = tuple< Number_as_type_<values>... >;
template< class Int_seq_a, class Int_seq_b >
using Concat_ = decltype( tuple_cat( Int_seq_a(), Int_seq_b() ) );
template< int max_index >
struct Index_sequence_t_
{
using T = Concat_<
typename Index_sequence_t_<max_index-1>::T, Int_sequence_<max_index>
>;
};
template<>
struct Index_sequence_t_<0> { using T = Int_sequence_<0>; };
template< int n_indices >
using Index_sequence_ = typename Index_sequence_t_<n_indices - 1>::T;
} // namespace my
Unfortunately Visual C++ 12.0 (2013) chokes on template argument deduction for the above Int_sequence_. Apparently it has to do with erroneously treating a templated using as a kind automatically referenced local typedef in a class. Anyway, working with that understanding of the Visual C++ compiler bug I rewrote the above as follows, which appears to work nicely also with Visual C++:
A version that works better with Visual C++ 12.0
namespace my {
using std::tuple;
using std::tuple_cat;
template< int i >
struct Number_as_type_ {};
template< int... values >
struct Int_sequence_
{
using As_tuple = tuple< Number_as_type_<values>... >;
};
template< int... values >
auto int_seq_from( tuple< Number_as_type_<values>... > )
-> Int_sequence_< values... >;
template< class Int_seq_a, class Int_seq_b >
using Concat_ = decltype(
int_seq_from( tuple_cat(
typename Int_seq_a::As_tuple(), typename Int_seq_b::As_tuple()
) )
);
template< int n_indices >
struct Index_sequence_t_
{
using T = Concat_<
typename Index_sequence_t_<n_indices-1>::T, Int_sequence_<n_indices-1>
>;
};
template<>
struct Index_sequence_t_<1> { using T = Int_sequence_<0>; };
template< int n_indices >
using Index_sequence_ = typename Index_sequence_t_<n_indices>::T;
} // namespace my
With the above C++11-based support available, a general compile time indexing for loop, or, if you will, template-based loop unrolling, can be implemented in C++11, so that code like this can be written:
template< int i >
struct Add_
{
void operator()( int sum[], int const a[], int const b[] ) const
{
sum[i] = a[i] + b[i];
}
};
#include <iostream>
using namespace std;
auto main() -> int
{
int sum[5];
int const a[] = {1, 2, 3, 4, 5};
int const b[] = {100, 200, 300, 400, 500};
my::for_each_index<5, Add_>( sum, a, b );
for( int x: sum ) { cout << x << ' '; } cout << endl;
}
Do note, however, that while this may appear to be the next best thing since sliced pizza, I suspect that any reasonably good compiler will do loop unrolling optimizations as a matter of course, i.e. that there is not necessarily any advantage to be gained from introducing this bit of extra complexity.
As always with respect to optimizations, do MEASURE.
This design does total loop unrolling, that is, instead of n executions of a loop body with varying index you get n instances of the loop body with different index values. It's not necessarily the best approach, e.g. since larger code has less chance of fitting in a cache (repeat: for optimizations always measure), and for parallelism you may have special requirements. You can check out “Duff’s device” for a technique for more limited loop unrolling.
namespace my {
using std::forward;
using std::initializer_list;
template< class Type >
void evaluate( initializer_list< Type > const& ) {}
namespace impl {
template< template <int> class Functor_, class... Args >
struct Call_with_numbers_
{
template< int... numbers >
void operator()( Int_sequence_<numbers...> const&, Args&&... args ) const
{
evaluate( {(Functor_<numbers>()( args... ), 0)...} );
}
};
} // namespace impl
template< int n, template<int> class Functor_, class... Args >
void for_each_index( Args&&... args )
{
using Seq = Index_sequence_<n>;
Seq s;
impl::Call_with_numbers_< Functor_, Args... >()( s, forward<Args>( args )... );
}
} // namespace my
Disclaimer: coded up late at night, so not necessarily very perfect! :-/