Classes | Namespaces | Macros | Functions | Variables
packetmath_test_shared.h File Reference
#include "main.h"
#include <typeinfo>

Go to the source code of this file.

Classes

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

 Eigen
 Namespace containing all symbols from the Eigen library.
 
 Eigen::test
 

Macros

#define CHECK_CWISE1(REFOP, POP)
 
#define CHECK_CWISE1_N(REFOP, POP, N)
 
#define CHECK_CWISE1_IM1ULP_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 , std::enable_if_t< NumTraits< T >::IsSigned, bool > = true>
T Eigen::test::negate (const T &x)
 
template<typename T >
Map< const Array< unsigned char, sizeof(T), 1 > > Eigen::test::bits (const T &x)
 
template<typename T >
bool Eigen::test::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)
 
template<typename Scalar >
bool Eigen::test::areApprox (const Scalar *a, const Scalar *b, int size, const typename NumTraits< Scalar >::Real &precision)
 

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); \
}
i
int i
Definition: BiCGSTAB_step_by_step.cpp:9
Eigen::internal::pstore
EIGEN_DEVICE_FUNC void pstore(Scalar *to, const Packet &from)
Definition: GenericPacketMath.h:891
Eigen::test::areApprox
bool areApprox(const Scalar *a, const Scalar *b, int size, const typename NumTraits< Scalar >::Real &precision)
Definition: packetmath_test_shared.h:98

◆ 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); \
}
Scalar
SCALAR Scalar
Definition: bench_gemm.cpp:45

◆ 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); \
}
Eigen::test::areEqual
bool areEqual(const Scalar *a, const Scalar *b, int size)
Definition: packetmath_test_shared.h:85

◆ 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_IM1ULP_N

#define CHECK_CWISE1_IM1ULP_N (   REFOP,
  POP,
  N 
)
Value:
{ \
RealScalar eps_1ulp = RealScalar(1e1) * std::numeric_limits<RealScalar>::epsilon(); \
for (int j = 0; j < N; j += PacketSize) \
internal::pstore(data2 + j, internal::plog(internal::pload<Packet>(data1 + j))); \
for (int i = 0; i < N; ++i) { \
ref[i] = REFOP(data1[i]); \
realref[i] = ref[i].imag(); \
realdata[i] = data2[i].imag(); \
} \
VERIFY(test::areApprox(realdata, realref, N, eps_1ulp)); \
for (int i = 0; i < N; ++i) { \
realdata[i] = data2[i].real(); \
realref[i] = ref[i].real(); \
} \
VERIFY(test::areApprox(realdata, realref, N)); \
}
RealScalar
NumTraits< Scalar >::Real RealScalar
Definition: bench_gemm.cpp:46
N
@ N
Definition: constructor.cpp:22
Eigen::internal::plog
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet plog(const Packet &a)
Definition: GenericPacketMath.h:1103
oomph::SarahBL::epsilon
double epsilon
Definition: osc_ring_sarah_asymptotics.h:43
j
std::ptrdiff_t j
Definition: tut_arithmetic_redux_minmax.cpp:2

◆ 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); \
}

Variable Documentation

◆ g_first_pass

bool g_first_pass = true

Referenced by EIGEN_DECLARE_TEST(), and packetmath().