vec_fb.h File Reference

Fallback vectorized class. More...

#include <initializer_list>
#include <type_traits>
#include <algorithm>
#include <cstdint>
#include "CxxUtils/bit_int.h"

Include dependency graph for vec_fb.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	CxxUtils::vec_fb< T, N >

Namespaces
namespace	CxxUtils

Macros
#define	BINOP(op)
#define	UNOP(op)
#define	RELOP(op)

Typedefs
template<typename T, size_t N>
using	CxxUtils::ivec = vec_fb<CxxUtils::bit_int_t<sizeof(T) * 8>, N>

Functions
template<typename T, size_t N>
ivec< T, N >	CxxUtils::operator! (const vec_fb< T, N > &a)
	Negation.
template<typename T, size_t N>
ivec< T, N >	CxxUtils::operator&& (const vec_fb< T, N > &a, const vec_fb< T, N > &b)
	V1 && V2.
template<typename T, size_t N, class U>
ivec< T, N >	CxxUtils::operator&& (U a, const vec_fb< T, N > &b)
	S && V.
template<typename T, size_t N, class U>
ivec< T, N >	CxxUtils::operator&& (const vec_fb< T, N > &a, U b)
	V && S.
template<typename T, size_t N>
ivec< T, N >	CxxUtils::operator|| (const vec_fb< T, N > &a, const vec_fb< T, N > &b)
	V1 || V2.

Detailed Description

Fallback vectorized class.

Author

scott snyder snyde.nosp@m.r@bn.nosp@m.l.gov

This is intended to be (mostly) functionally equivalent to the built-in vectorized types. (One difference is that we don't support ?:, as that can't be overloaded.)

Definition in file vec_fb.h.

Macro Definition Documentation

BINOP

#define BINOP

(

op

)

Definition at line 62 of file vec_fb.h.

#define BINOP(op)                                                              \
  template<typename T, size_t N>                                               \
  inline vec_fb<T, N> operator op(const vec_fb<T, N>& a,                       \
                                  const vec_fb<T, N>& b)                       \
  {                                                                            \
    vec_fb<T, N> c;                                                            \
    for (size_t i = 0; i < N; ++i)                                             \
      c.m_arr[i] = a.m_arr[i] op b.m_arr[i];                                   \
    return c;                                                                  \
  }                                                                            \
  template<typename T, size_t N, typename U>                                   \
  inline vec_fb<T, N> operator op(const vec_fb<T, N>& a, U b)                  \
  {                                                                            \
    vec_fb<T, N> c;                                                            \
    for (size_t i = 0; i < N; ++i)                                             \
      c.m_arr[i] = a.m_arr[i] op b;                                            \
    return c;                                                                  \
  }                                                                            \
  template<typename T, size_t N, typename U>                                   \
  inline vec_fb<T, N> operator op(U a, const vec_fb<T, N>& b)                  \
  {                                                                            \
    vec_fb<T, N> c;                                                            \
    for (size_t i = 0; i < N; ++i)                                             \
      c.m_arr[i] = a op b.m_arr[i];                                            \
    return c;                                                                  \
  }                                                                            \
  template<typename T, size_t N>                                               \
  inline vec_fb<T, N>& operator op##=(vec_fb<T, N>& a, const vec_fb<T, N>& b)  \
  {                                                                            \
    for (size_t i = 0; i < N; ++i)                                             \
      a.m_arr[i] op## = b.m_arr[i];                                            \
    return a;                                                                  \
  }                                                                            \
  template<typename T, size_t N, typename U>                                   \
  inline vec_fb<T, N>& operator op##=(vec_fb<T, N>& a, U b)                    \
  {                                                                            \
    for (size_t i = 0; i < N; ++i)                                             \
      a.m_arr[i] op## = b;                                                     \
    return a;                                                                  \
  }

RELOP

#define RELOP

(

op

)

Value:

template<typename T, size_t N>                                               \
inline ivec<T, N> operator op(const vec_fb<T, N>& a, const vec_fb<T, N>& b)  \
{                                                                            \
  ivec<T, N> c;                                                              \
  for (size_t i = 0; i < N; ++i)                                             \
    c.m_arr[i] = a.m_arr[i] op b.m_arr[i];                                   \
  return c;                                                                  \
}

Definition at line 135 of file vec_fb.h.

#define RELOP(op)                                                              \
  template<typename T, size_t N>                                               \
  inline ivec<T, N> operator op(const vec_fb<T, N>& a, const vec_fb<T, N>& b)  \
  {                                                                            \
    ivec<T, N> c;                                                              \
    for (size_t i = 0; i < N; ++i)                                             \
      c.m_arr[i] = a.m_arr[i] op b.m_arr[i];                                   \
    return c;                                                                  \
  }

UNOP

#define UNOP

(

op

)

Value:

template<typename T, size_t N>                                               \
inline vec_fb<T, N> operator op(const vec_fb<T, N>& a)                       \
{                                                                            \
  vec_fb<T, N> c;                                                            \
  for (size_t i = 0; i < N; ++i)                                             \
    c.m_arr[i] = op a.m_arr[i];                                              \
  return c;                                                                  \
}

Definition at line 118 of file vec_fb.h.

#define UNOP(op)                                                               \
  template<typename T, size_t N>                                               \
  inline vec_fb<T, N> operator op(const vec_fb<T, N>& a)                       \
  {                                                                            \
    vec_fb<T, N> c;                                                            \
    for (size_t i = 0; i < N; ++i)                                             \
      c.m_arr[i] = op a.m_arr[i];                                              \
    return c;                                                                  \
  }