implementation< vector_abstractions_stride, V, vector_naive > Struct Template Reference

#include <vector_naive.hpp>

Static Public Member Functions

template<typename Op , typename T > static void vec_nullary_stride (T *dest, nat dest_stride, nat n)
template<typename Op , typename T , typename C > static void vec_unary_stride (T *dest, nat dest_stride, const C *s, nat s_stride, nat n)
template<typename Op , typename T , typename C1 , typename C2 > static void vec_binary_stride (T *dest, nat dest_stride, const C1 *s1, nat s1_stride, const C2 *s2, nat s2_stride, nat n)
template<typename Op , typename T , typename X > static void vec_unary_scalar_stride (T *dest, nat dest_stride, const X &x, nat n)
template<typename Op , typename T , typename C , typename X > static void vec_binary_scalar_stride (T *dest, nat dest_stride, const C *s, nat s_stride, const X &x, nat n)
template<typename Op , typename C1 , typename C2 > static void vec_binary_combine_stride (C1 *d1, nat d1_stride, C2 *d2, nat d2_stride, nat n)
template<typename Op , typename C > static bool vec_unary_test_stride (const C *s, nat s_stride, nat n)
template<typename Op , typename C1 , typename C2 > static bool vec_binary_test_stride (const C1 *s1, nat s1_stride, const C2 *s2, nat s2_stride, nat n)
template<typename Op , typename C , typename X > static bool vec_binary_test_scalar_stride (const C *s, nat s_stride, const X &x, nat n)
template<typename Op , typename C > static C vec_unary_big_stride (const C *s, nat s_stride, nat n)
template<typename Op , typename C1 , typename C2 > static C1 vec_binary_big_stride (const C1 *s1, nat p1, const C2 *s2, nat p2, nat n)
template<typename Op , typename C > static C vec_unary_big_dicho_stride (const C *s, nat p, nat n)

Detailed Description

template<typename V>
struct mmx::implementation< vector_abstractions_stride, V, vector_naive >

Definition at line 220 of file vector_naive.hpp.

Member Function Documentation

static C1 vec_binary_big_stride	(	const C1 *	s1,
		nat	p1,
		const C2 *	s2,
		nat	p2,
		nat	n
	)			`[inline, static]`

Definition at line 295 of file vector_naive.hpp.

00295                                                                           {
00296   C1 r; Op::set_neutral (r); //= Op::template neutral<C1> ();
00297   for (; n != 0; s1 += p1, s2 += p2, n--)
00298     Op::set_op (r, *s1, *s2);
00299   return r;
00300 }

static void vec_binary_combine_stride	(	C1 *	d1,
		nat	d1_stride,
		C2 *	d2,
		nat	d2_stride,
		nat	n
	)			`[inline, static]`

Definition at line 257 of file vector_naive.hpp.

00258                                                          {
00259   for (; n != 0; d1 += d1_stride, d2 += d2_stride, n--)
00260     Op::set_op (*d1, *d2);
00261 }

static void vec_binary_scalar_stride	(	T *	dest,
		nat	dest_stride,
		const C *	s,
		nat	s_stride,
		const X &	x,
		nat	n
	)			`[inline, static]`

Definition at line 250 of file vector_naive.hpp.

00251                                              {
00252   for (; n != 0; dest += dest_stride, s += s_stride, n--)
00253     Op::set_op (*dest, *s, x);
00254 }

static void vec_binary_stride	(	T *	dest,
		nat	dest_stride,
		const C1 *	s1,
		nat	s1_stride,
		const C2 *	s2,
		nat	s2_stride,
		nat	n
	)			`[inline, static]`

Definition at line 237 of file vector_naive.hpp.

00238                                                        {
00239   for (; n != 0; dest += dest_stride, s1 += s1_stride, s2 += s2_stride, n--)
00240     Op::set_op (*dest, *s1, *s2);
00241 }

static bool vec_binary_test_scalar_stride	(	const C *	s,
		nat	s_stride,
		const X &	x,
		nat	n
	)			`[inline, static]`

Definition at line 279 of file vector_naive.hpp.

00279                                                                             {
00280   for (; n != 0; s += s_stride, n--)
00281     if (Op::not_op (*s, x)) return false;
00282   return true;
00283 }

static bool vec_binary_test_stride	(	const C1 *	s1,
		nat	s1_stride,
		const C2 *	s2,
		nat	s2_stride,
		nat	n
	)			`[inline, static]`

Definition at line 271 of file vector_naive.hpp.

00272                                                             {
00273   for (; n != 0; s1 += s1_stride, s2 += s2_stride, n--)
00274     if (Op::not_op (*s1, *s2)) return false;
00275   return true;
00276 }

static void vec_nullary_stride	(	T *	dest,
		nat	dest_stride,
		nat	n
	)			`[inline, static]`

Definition at line 225 of file vector_naive.hpp.

00225                                                      {
00226   for (; n != 0; dest += dest_stride, n--)
00227     Op::set_op (*dest);
00228 }

static C vec_unary_big_dicho_stride	(	const C *	s,
		nat	p,
		nat	n
	)			`[inline, static]`

Definition at line 303 of file vector_naive.hpp.

00303                                                       {
00304   switch (n) {
00305   case 0: return Op::template neutral<C> ();
00306   case 1: return s[0];
00307   case 2: return Op::op (s[0], s[p]);
00308   case 3: return Op::op (s[0], Op::op (s[p], s[p+p]));
00309   case 4: return Op::op (Op::op (s[0], s[p]), Op::op (s[p+p], s[p+p+p]));
00310   default:
00311     return Op::op (vec_unary_big_dicho_stride<Op> (s, p, n>>1),
00312                    vec_unary_big_dicho_stride<Op> (s + (n>>1), p, n - (n>>1)));
00313   }
00314 }

static C vec_unary_big_stride	(	const C *	s,
		nat	s_stride,
		nat	n
	)			`[inline, static]`

Definition at line 286 of file vector_naive.hpp.

References mmx::C.

00286                                                        {
00287   if (n == 0) return Op::template neutral<C> ();
00288   C r= *s;
00289   for (s += s_stride, n--; n != 0; s += s_stride, n--)
00290     Op::set_op (r, *s);
00291   return r;
00292 }

static void vec_unary_scalar_stride	(	T *	dest,
		nat	dest_stride,
		const X &	x,
		nat	n
	)			`[inline, static]`

Definition at line 244 of file vector_naive.hpp.

00244                                                                       {
00245   for (; n != 0; dest += dest_stride, n--)
00246     Op::set_op (*dest, x);
00247 }

static void vec_unary_stride	(	T *	dest,
		nat	dest_stride,
		const C *	s,
		nat	s_stride,
		nat	n
	)			`[inline, static]`

Definition at line 231 of file vector_naive.hpp.

00231                                                                              {
00232   for (; n != 0; dest += dest_stride, s += s_stride, n--)
00233     Op::set_op (*dest, *s);
00234 }

static bool vec_unary_test_stride	(	const C *	s,
		nat	s_stride,
		nat	n
	)			`[inline, static]`

Definition at line 264 of file vector_naive.hpp.

00264                                                         {
00265   for (; n != 0; s += s_stride, n--)
00266     if (Op::not_op (*s)) return false;
00267   return true;
00268 }

The documentation for this struct was generated from the following file:

include/basix/vector_naive.hpp

implementation< vector_abstractions_stride, V, vector_naive > Struct Template Reference

Static Public Member Functions

Detailed Description

template<typename V> struct mmx::implementation< vector_abstractions_stride, V, vector_naive >

Member Function Documentation

template<typename V>
struct mmx::implementation< vector_abstractions_stride, V, vector_naive >