packetmath_test_shared.h File Reference

#include "main.h"
#include <typeinfo>

Go to the source code of this file.

Classes
struct	Eigen::internal::bit_andnot
struct	Eigen::test::packet_helper< Cond, Packet >
struct	Eigen::test::packet_helper< false, Packet >
struct	Eigen::test::runner< Scalar, PacketType, true, true >
struct	Eigen::test::runner< Scalar, PacketType, true, false >
struct	Eigen::test::runner< Scalar, PacketType, false, false >

Namespaces
namespace	Eigen
	Namespace containing all symbols from the Eigen library.
namespace	Eigen::internal
namespace	Eigen::test

Macros
#define	EIGEN_TEST_MAKE_BITWISE2(OP, FUNC, T)
#define	EIGEN_TEST_MAKE_BITWISE(OP, FUNC)
#define	CHECK_CWISE1(REFOP, POP)
#define	CHECK_CWISE1_N(REFOP, POP, N)
#define	CHECK_CWISE1_IF(COND, REFOP, POP)
#define	CHECK_CWISE1_EXACT_IF(COND, REFOP, POP)
#define	CHECK_CWISE2_IF(COND, REFOP, POP)
#define	CHECK_CWISE1_BYREF1_IF(COND, REFOP, POP)
#define	CHECK_CWISE3_IF(COND, REFOP, POP)

Functions
template<typename T >
T	Eigen::internal::negate (const T &x)
template<typename T >
Map< const Array< unsigned char, sizeof(T), 1 > >	Eigen::internal::bits (const T &x)
template<typename T , typename Bits , typename Func >
T	Eigen::internal::apply_bit_op (Bits a, Bits b, Func f)
template<typename T >
bool	Eigen::internal::biteq (T a, T b)
template<typename Scalar >
EIGEN_DONT_INLINE bool	Eigen::test::isApproxAbs (const Scalar &a, const Scalar &b, const typename NumTraits< Scalar >::Real &refvalue)
template<typename Scalar >
void	Eigen::test::print_mismatch (const Scalar *ref, const Scalar *vec, int size)
template<typename Scalar >
bool	Eigen::test::areApproxAbs (const Scalar *a, const Scalar *b, int size, const typename NumTraits< Scalar >::Real &refvalue)
template<typename Scalar >
bool	Eigen::test::areApprox (const Scalar *a, const Scalar *b, int size)
template<typename Scalar >
bool	Eigen::test::areEqual (const Scalar *a, const Scalar *b, int size)

Variables
bool	g_first_pass = true

Macro Definition Documentation

CHECK_CWISE1

#define CHECK_CWISE1	(		REFOP,
			POP
	)

Value:

  { \
  for (int i=0; i<PacketSize; ++i) \
    ref[i] = REFOP(data1[i]); \
  internal::pstore(data2, POP(internal::pload<Packet>(data1))); \
  VERIFY(test::areApprox(ref, data2, PacketSize) && #POP); \
}

CHECK_CWISE1_BYREF1_IF

#define CHECK_CWISE1_BYREF1_IF	(		COND,
			REFOP,
			POP
	)

Value:

  if(COND) { \
  test::packet_helper<COND,Packet> h; \
  for (int i=0; i<PacketSize; ++i) \
    ref[i] = Scalar(REFOP(data1[i], ref[i+PacketSize]));     \
  Packet pout; \
  Scalar sout; \
  h.store(data2, POP(h.load(data1), h.forward_reference(pout, sout))); \
  h.store(data2+PacketSize, h.forward_reference(pout, sout)); \
  VERIFY(test::areApprox(ref, data2, 2 * PacketSize) && #POP); \
}

CHECK_CWISE1_EXACT_IF

#define CHECK_CWISE1_EXACT_IF	(		COND,
			REFOP,
			POP
	)

Value:

  if(COND) { \
  test::packet_helper<COND,Packet> h; \
  for (int i=0; i<PacketSize; ++i) \
    ref[i] = Scalar(REFOP(data1[i])); \
  h.store(data2, POP(h.load(data1))); \
  VERIFY(test::areEqual(ref, data2, PacketSize) && #POP); \
}

CHECK_CWISE1_IF

#define CHECK_CWISE1_IF	(		COND,
			REFOP,
			POP
	)

Value:

  if(COND) { \
  test::packet_helper<COND,Packet> h; \
  for (int i=0; i<PacketSize; ++i) \
    ref[i] = Scalar(REFOP(data1[i])); \
  h.store(data2, POP(h.load(data1))); \
  VERIFY(test::areApprox(ref, data2, PacketSize) && #POP); \
}

CHECK_CWISE1_N

#define CHECK_CWISE1_N	(		REFOP,
			POP,
			N
	)

Value:

  { \
  for (int i=0; i<N; ++i) \
    ref[i] = REFOP(data1[i]); \
  for (int j=0; j<N; j+=PacketSize) \
    internal::pstore(data2 + j, POP(internal::pload<Packet>(data1 + j))); \
  VERIFY(test::areApprox(ref, data2, N) && #POP); \
}

CHECK_CWISE2_IF

#define CHECK_CWISE2_IF	(		COND,
			REFOP,
			POP
	)

Value:

  if(COND) { \
  test::packet_helper<COND,Packet> h; \
  for (int i=0; i<PacketSize; ++i) \
    ref[i] = Scalar(REFOP(data1[i], data1[i+PacketSize]));     \
  h.store(data2, POP(h.load(data1),h.load(data1+PacketSize))); \
  VERIFY(test::areApprox(ref, data2, PacketSize) && #POP); \
}

CHECK_CWISE3_IF

#define CHECK_CWISE3_IF	(		COND,
			REFOP,
			POP
	)

Value:

  if (COND) {                      \
  test::packet_helper<COND, Packet> h;                                     \
  for (int i = 0; i < PacketSize; ++i)                                     \
    ref[i] = Scalar(REFOP(data1[i], data1[i + PacketSize],                 \
                          data1[i + 2 * PacketSize]));                     \
  h.store(data2, POP(h.load(data1), h.load(data1 + PacketSize),            \
                     h.load(data1 + 2 * PacketSize)));                     \
  VERIFY(test::areApprox(ref, data2, PacketSize) && #POP);                 \
}

EIGEN_TEST_MAKE_BITWISE

#define EIGEN_TEST_MAKE_BITWISE	(		OP,
			FUNC
	)

Value:

  EIGEN_TEST_MAKE_BITWISE2(OP,FUNC,float)                 \
  EIGEN_TEST_MAKE_BITWISE2(OP,FUNC,double)                \
  EIGEN_TEST_MAKE_BITWISE2(OP,FUNC,half)                  \
  EIGEN_TEST_MAKE_BITWISE2(OP,FUNC,bfloat16)              \
  EIGEN_TEST_MAKE_BITWISE2(OP,FUNC,std::complex<float>)   \
  EIGEN_TEST_MAKE_BITWISE2(OP,FUNC,std::complex<double>)

EIGEN_TEST_MAKE_BITWISE2

#define EIGEN_TEST_MAKE_BITWISE2	(		OP,
			FUNC,
			T
	)

Value:

  template<> T EIGEN_CAT(p,OP)(const T& a,const T& b) { \
    return apply_bit_op<T>(bits(a),bits(b),FUNC);     \
  }

Variable Documentation

g_first_pass

bool g_first_pass = true