Classes | Namespaces | Macros | Functions
special_packetmath.cpp File Reference
#include <limits>
#include "packetmath_test_shared.h"
#include "../Eigen/SpecialFunctions"

Classes

struct  Eigen::test::runall< Scalar, PacketType, IsComplex, IsInteger >
 

Namespaces

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

Macros

#define MAYBE_FLUSH(op)   op
 

Functions

template<typename Scalar , typename Packet >
void packetmath_real ()
 
 EIGEN_DECLARE_TEST (special_packetmath)
 

Macro Definition Documentation

◆ MAYBE_FLUSH

#define MAYBE_FLUSH (   op)    op

Function Documentation

◆ EIGEN_DECLARE_TEST()

EIGEN_DECLARE_TEST ( special_packetmath  )
151  {
152  g_first_pass = true;
153  for (int i = 0; i < g_repeat; i++) {
154  CALL_SUBTEST_1(test::runner<float>::run());
155  CALL_SUBTEST_2(test::runner<double>::run());
156  CALL_SUBTEST_3(test::runner<Eigen::half>::run());
157  CALL_SUBTEST_4(test::runner<Eigen::bfloat16>::run());
158  g_first_pass = false;
159  }
160 }
i
int i
Definition: BiCGSTAB_step_by_step.cpp:9
Eigen::g_repeat
static int g_repeat
Definition: main.h:191
g_first_pass
bool g_first_pass
Definition: packetmath_test_shared.h:19
CALL_SUBTEST_3
#define CALL_SUBTEST_3(FUNC)
Definition: split_test_helper.h:16
CALL_SUBTEST_1
#define CALL_SUBTEST_1(FUNC)
Definition: split_test_helper.h:4
CALL_SUBTEST_2
#define CALL_SUBTEST_2(FUNC)
Definition: split_test_helper.h:10
CALL_SUBTEST_4
#define CALL_SUBTEST_4(FUNC)
Definition: split_test_helper.h:22
run
void run(const string &dir_name, LinearSolver *linear_solver_pt, const unsigned nel_1d, bool mess_up_order)
Definition: two_d_poisson_compare_solvers.cc:317

References CALL_SUBTEST_1, CALL_SUBTEST_2, CALL_SUBTEST_3, CALL_SUBTEST_4, g_first_pass, Eigen::g_repeat, i, and run().

◆ packetmath_real()

template<typename Scalar , typename Packet >
void packetmath_real ( )
30  {
31  using std::abs;
32  typedef internal::packet_traits<Scalar> PacketTraits;
33  const int PacketSize = internal::unpacket_traits<Packet>::size;
34 
35  const int size = PacketSize * 4;
36  EIGEN_ALIGN_MAX Scalar data1[PacketSize * 4] = {};
37  EIGEN_ALIGN_MAX Scalar data2[PacketSize * 4] = {};
38  EIGEN_ALIGN_MAX Scalar ref[PacketSize * 4] = {};
39 
40 #if EIGEN_HAS_C99_MATH
41  {
42  data1[0] = std::numeric_limits<Scalar>::quiet_NaN();
43  test::packet_helper<internal::packet_traits<Scalar>::HasLGamma, Packet> h;
44  h.store(data2, internal::plgamma(h.load(data1)));
45  VERIFY((numext::isnan)(data2[0]));
46  }
47  if (internal::packet_traits<Scalar>::HasErf) {
48  data1[0] = std::numeric_limits<Scalar>::quiet_NaN();
49  test::packet_helper<internal::packet_traits<Scalar>::HasErf, Packet> h;
50  h.store(data2, internal::perf(h.load(data1)));
51  VERIFY((numext::isnan)(data2[0]));
52  }
53  {
54  data1[0] = std::numeric_limits<Scalar>::quiet_NaN();
55  test::packet_helper<internal::packet_traits<Scalar>::HasErfc, Packet> h;
56  h.store(data2, internal::perfc(h.load(data1)));
57  VERIFY((numext::isnan)(data2[0]));
58  }
59  {
60  for (int i = 0; i < size; ++i) {
61  data1[i] = internal::random<Scalar>(Scalar(0), Scalar(1));
62  }
63  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasNdtri, numext::ndtri, internal::pndtri);
64  }
65 #endif // EIGEN_HAS_C99_MATH
66 
67  // For bessel_i*e and bessel_j*, the valid range is negative reals.
68  {
69  const int max_exponent = numext::mini(std::numeric_limits<Scalar>::max_exponent10 - 1, 6);
70  for (int i = 0; i < size; ++i) {
71  data1[i] = internal::random<Scalar>(Scalar(-1), Scalar(1)) *
72  Scalar(std::pow(Scalar(10), internal::random<Scalar>(Scalar(-max_exponent), Scalar(max_exponent))));
73  data2[i] = internal::random<Scalar>(Scalar(-1), Scalar(1)) *
74  Scalar(std::pow(Scalar(10), internal::random<Scalar>(Scalar(-max_exponent), Scalar(max_exponent))));
75  }
76 
77  CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_i0e, internal::pbessel_i0e);
78  CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_i1e, internal::pbessel_i1e);
79  CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_j0, internal::pbessel_j0);
80  CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_j1, internal::pbessel_j1);
81  }
82 
83  // Use a smaller data range for the bessel_i* as these can become very large.
84  // Following #1693, we also restrict this range further to avoid inf's due to
85  // differences in pexp and exp.
86  for (int i = 0; i < size; ++i) {
87  data1[i] = internal::random<Scalar>(Scalar(0.01), Scalar(1)) *
88  Scalar(std::pow(Scalar(9), internal::random<Scalar>(Scalar(-1), Scalar(2))));
89  data2[i] = internal::random<Scalar>(Scalar(0.01), Scalar(1)) *
90  Scalar(std::pow(Scalar(9), internal::random<Scalar>(Scalar(-1), Scalar(2))));
91  }
92  CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_i0, internal::pbessel_i0);
93  CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_i1, internal::pbessel_i1);
94 
95  // y_i, and k_i are valid for x > 0.
96  {
97  const int max_exponent = numext::mini(std::numeric_limits<Scalar>::max_exponent10 - 1, 5);
98  for (int i = 0; i < size; ++i) {
99  data1[i] = internal::random<Scalar>(Scalar(0.01), Scalar(1)) *
100  Scalar(std::pow(Scalar(10), internal::random<Scalar>(Scalar(-2), Scalar(max_exponent))));
101  data2[i] = internal::random<Scalar>(Scalar(0.01), Scalar(1)) *
102  Scalar(std::pow(Scalar(10), internal::random<Scalar>(Scalar(-2), Scalar(max_exponent))));
103  }
104  }
105 
106  // TODO(srvasude): Re-enable this test once properly investigated why the
107  // scalar and vector paths differ.
108  // CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_y0, internal::pbessel_y0);
109  CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_y1, internal::pbessel_y1);
110  CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_k0e, internal::pbessel_k0e);
111  CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_k1e, internal::pbessel_k1e);
112 
113  // Following #1693, we restrict the range for exp to avoid zeroing out too
114  // fast.
115  for (int i = 0; i < size; ++i) {
116  data1[i] = internal::random<Scalar>(Scalar(0.01), Scalar(1)) *
117  Scalar(std::pow(Scalar(9), internal::random<Scalar>(Scalar(-1), Scalar(2))));
118  data2[i] = internal::random<Scalar>(Scalar(0.01), Scalar(1)) *
119  Scalar(std::pow(Scalar(9), internal::random<Scalar>(Scalar(-1), Scalar(2))));
120  }
121  CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_k0, internal::pbessel_k0);
122  CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_k1, internal::pbessel_k1);
123 
124  for (int i = 0; i < size; ++i) {
125  data1[i] = internal::random<Scalar>(Scalar(0.01), Scalar(1)) *
126  Scalar(std::pow(Scalar(10), internal::random<Scalar>(Scalar(-1), Scalar(2))));
127  data2[i] = internal::random<Scalar>(Scalar(0.01), Scalar(1)) *
128  Scalar(std::pow(Scalar(10), internal::random<Scalar>(Scalar(-1), Scalar(2))));
129  }
130 
131 #if EIGEN_HAS_C99_MATH
132  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasLGamma, std::lgamma, internal::plgamma);
133  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasErf, std::erf, internal::perf);
134  // FIXME(rmlarsen): This test occasionally fails due to difference in tiny subnormal results
135  // near the underflow boundary. I am not sure which version is correct.
136  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasErfc, MAYBE_FLUSH(std::erfc), internal::perfc);
137 #endif
138 }
abs
AnnoyingScalar abs(const AnnoyingScalar &x)
Definition: AnnoyingScalar.h:135
EIGEN_ALIGN_MAX
#define EIGEN_ALIGN_MAX
Definition: ConfigureVectorization.h:146
size
Scalar Scalar int size
Definition: benchVecAdd.cpp:17
Scalar
SCALAR Scalar
Definition: bench_gemm.cpp:45
VERIFY
#define VERIFY(a)
Definition: main.h:362
isnan
#define isnan(X)
Definition: main.h:109
Eigen::bfloat16_impl::pow
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 pow(const bfloat16 &a, const bfloat16 &b)
Definition: BFloat16.h:625
Eigen::internal::pbessel_i0
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_i0(const Packet &x)
Definition: BesselFunctionsPacketMath.h:23
Eigen::internal::pbessel_i1e
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_i1e(const Packet &x)
Definition: BesselFunctionsPacketMath.h:44
Eigen::internal::pndtri
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pndtri(const Packet &a)
Definition: SpecialFunctionsPacketMath.h:64
Eigen::internal::pbessel_i0e
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_i0e(const Packet &x)
Definition: BesselFunctionsPacketMath.h:30
Eigen::internal::perf
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet perf(const Packet &a)
Definition: SpecialFunctionsPacketMath.h:50
Eigen::internal::perfc
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet perfc(const Packet &a)
Definition: SpecialFunctionsPacketMath.h:57
Eigen::internal::pbessel_k1e
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_k1e(const Packet &x)
Definition: BesselFunctionsPacketMath.h:100
Eigen::internal::pbessel_j1
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_j1(const Packet &x)
Definition: BesselFunctionsPacketMath.h:58
Eigen::internal::pbessel_k0
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_k0(const Packet &x)
Definition: BesselFunctionsPacketMath.h:79
Eigen::internal::plgamma
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet plgamma(const Packet &a)
Definition: SpecialFunctionsPacketMath.h:22
Eigen::internal::pbessel_i1
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_i1(const Packet &x)
Definition: BesselFunctionsPacketMath.h:37
Eigen::internal::pbessel_k1
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_k1(const Packet &x)
Definition: BesselFunctionsPacketMath.h:93
Eigen::internal::pbessel_y1
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_y1(const Packet &x)
Definition: BesselFunctionsPacketMath.h:72
Eigen::internal::pbessel_k0e
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_k0e(const Packet &x)
Definition: BesselFunctionsPacketMath.h:86
Eigen::internal::pbessel_j0
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_j0(const Packet &x)
Definition: BesselFunctionsPacketMath.h:51
Eigen::numext::mini
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T mini(const T &x, const T &y)
Definition: MathFunctions.h:920
Eigen::bessel_k0e
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k0e_op< typename Derived::Scalar >, const Derived > bessel_k0e(const Eigen::ArrayBase< Derived > &x)
Definition: BesselFunctionsArrayAPI.h:142
Eigen::bessel_j1
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_j1_op< typename Derived::Scalar >, const Derived > bessel_j1(const Eigen::ArrayBase< Derived > &x)
Definition: BesselFunctionsArrayAPI.h:248
Eigen::bessel_i0e
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i0e_op< typename Derived::Scalar >, const Derived > bessel_i0e(const Eigen::ArrayBase< Derived > &x)
Definition: BesselFunctionsArrayAPI.h:56
Eigen::bessel_k1
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k1_op< typename Derived::Scalar >, const Derived > bessel_k1(const Eigen::ArrayBase< Derived > &x)
Definition: BesselFunctionsArrayAPI.h:163
Eigen::bessel_j0
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_j0_op< typename Derived::Scalar >, const Derived > bessel_j0(const Eigen::ArrayBase< Derived > &x)
Definition: BesselFunctionsArrayAPI.h:206
Eigen::bessel_k0
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k0_op< typename Derived::Scalar >, const Derived > bessel_k0(const Eigen::ArrayBase< Derived > &x)
Definition: BesselFunctionsArrayAPI.h:120
Eigen::bessel_i1e
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i1e_op< typename Derived::Scalar >, const Derived > bessel_i1e(const Eigen::ArrayBase< Derived > &x)
Definition: BesselFunctionsArrayAPI.h:99
Eigen::bessel_k1e
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k1e_op< typename Derived::Scalar >, const Derived > bessel_k1e(const Eigen::ArrayBase< Derived > &x)
Definition: BesselFunctionsArrayAPI.h:185
Eigen::bessel_i1
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i1_op< typename Derived::Scalar >, const Derived > bessel_i1(const Eigen::ArrayBase< Derived > &x)
Definition: BesselFunctionsArrayAPI.h:77
Eigen::bessel_i0
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i0_op< typename Derived::Scalar >, const Derived > bessel_i0(const Eigen::ArrayBase< Derived > &x)
Definition: BesselFunctionsArrayAPI.h:34
Eigen::bessel_y1
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_y1_op< typename Derived::Scalar >, const Derived > bessel_y1(const Eigen::ArrayBase< Derived > &x)
Definition: BesselFunctionsArrayAPI.h:269
CHECK_CWISE1_IF
#define CHECK_CWISE1_IF(COND, REFOP, POP)
Definition: packetmath_test_shared.h:217
MAYBE_FLUSH
#define MAYBE_FLUSH(op)
Definition: special_packetmath.cpp:26

References abs(), Eigen::bessel_i0(), Eigen::bessel_i0e(), Eigen::bessel_i1(), Eigen::bessel_i1e(), Eigen::bessel_j0(), Eigen::bessel_j1(), Eigen::bessel_k0(), Eigen::bessel_k0e(), Eigen::bessel_k1(), Eigen::bessel_k1e(), Eigen::bessel_y1(), CHECK_CWISE1_IF, EIGEN_ALIGN_MAX, i, isnan, MAYBE_FLUSH, Eigen::numext::mini(), Eigen::internal::pbessel_i0(), Eigen::internal::pbessel_i0e(), Eigen::internal::pbessel_i1(), Eigen::internal::pbessel_i1e(), Eigen::internal::pbessel_j0(), Eigen::internal::pbessel_j1(), Eigen::internal::pbessel_k0(), Eigen::internal::pbessel_k0e(), Eigen::internal::pbessel_k1(), Eigen::internal::pbessel_k1e(), Eigen::internal::pbessel_y1(), Eigen::internal::perf(), Eigen::internal::perfc(), Eigen::internal::plgamma(), Eigen::internal::pndtri(), Eigen::bfloat16_impl::pow(), size, and VERIFY.