Classes | Functions
matrix_cwise.cpp File Reference
#include <vector>
#include "main.h"

Classes

struct  matrix_of< MatrixType, NewScalar >
 
struct  matrix_of< Eigen::Matrix< Scalar, Rows, Cols, Options, MaxRows, MaxCols >, NewScalar >
 

Functions

template<typename MatrixType , typename Func , typename OutMatrixType = typename matrix_of< MatrixType, typename Eigen::internal::result_of<Func(typename MatrixType::Scalar)>::type>::type>
OutMatrixType cwise_ref (const MatrixType &m, Func f=Func())
 
template<typename MatrixType , typename Func , typename OutMatrixType = typename matrix_of< MatrixType, typename Eigen::internal::result_of<Func(typename MatrixType::Scalar, typename MatrixType::Scalar)>::type>::type>
OutMatrixType cwise_ref (const MatrixType &m1, const MatrixType &m2, Func f=Func())
 
template<typename MatrixType >
void test_cwise_real (const MatrixType &m)
 
template<typename MatrixType >
void test_cwise_complex (const MatrixType &m)
 
 EIGEN_DECLARE_TEST (matrix_cwise)
 

Function Documentation

◆ cwise_ref() [1/2]

template<typename MatrixType , typename Func , typename OutMatrixType = typename matrix_of< MatrixType, typename Eigen::internal::result_of<Func(typename MatrixType::Scalar)>::type>::type>
OutMatrixType cwise_ref ( const MatrixType &  m,
Func  f = Func() 
)
27  {
28  OutMatrixType out(m.rows(), m.cols());
29  for (Eigen::Index r = 0; r < m.rows(); ++r) {
30  for (Eigen::Index c = 0; c < m.cols(); ++c) {
31  out(r, c) = f(m(r, c));
32  }
33  }
34  return out;
35 }
f
static int f(const TensorMap< Tensor< int, 3 > > &tensor)
Definition: cxx11_tensor_map.cpp:237
m
int * m
Definition: level2_cplx_impl.h:294
Eigen::Index
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:83
UniformPSDSelfTest.r
r
Definition: UniformPSDSelfTest.py:20
calibrate.c
int c
Definition: calibrate.py:100
out
std::ofstream out("Result.txt")

References calibrate::c, f(), m, out(), and UniformPSDSelfTest::r.

Referenced by test_cwise_complex(), and test_cwise_real().

◆ cwise_ref() [2/2]

template<typename MatrixType , typename Func , typename OutMatrixType = typename matrix_of< MatrixType, typename Eigen::internal::result_of<Func(typename MatrixType::Scalar, typename MatrixType::Scalar)>::type>::type>
OutMatrixType cwise_ref ( const MatrixType &  m1,
const MatrixType &  m2,
Func  f = Func() 
)
42  {
43  OutMatrixType out(m1.rows(), m1.cols());
44  for (Eigen::Index r = 0; r < m1.rows(); ++r) {
45  for (Eigen::Index c = 0; c < m1.cols(); ++c) {
46  out(r, c) = f(m1(r, c), m2(r, c));
47  }
48  }
49  return out;
50 }
m1
Matrix3d m1
Definition: IOFormat.cpp:2
m2
MatrixType m2(n_dims)

References calibrate::c, f(), m1, m2(), out(), and UniformPSDSelfTest::r.

◆ EIGEN_DECLARE_TEST()

EIGEN_DECLARE_TEST ( matrix_cwise  )
285  {
286  for (int i = 0; i < g_repeat; i++) {
287  CALL_SUBTEST_1(test_cwise_real(Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic>(20, 20)));
288  CALL_SUBTEST_1(test_cwise_real(Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>(20, 20)));
289  CALL_SUBTEST_1(test_cwise_real(Eigen::Matrix<Eigen::half, Eigen::Dynamic, Eigen::Dynamic>(20, 20)));
290  CALL_SUBTEST_1(test_cwise_real(Eigen::Matrix<Eigen::bfloat16, Eigen::Dynamic, Eigen::Dynamic>(20, 20)));
291  CALL_SUBTEST_2(test_cwise_complex(Eigen::Matrix<std::complex<float>, Eigen::Dynamic, Eigen::Dynamic>(20, 20)));
292  CALL_SUBTEST_2(test_cwise_complex(Eigen::Matrix<std::complex<double>, Eigen::Dynamic, Eigen::Dynamic>(20, 20)));
293  CALL_SUBTEST_3(test_cwise_real(Eigen::Matrix<int8_t, Eigen::Dynamic, Eigen::Dynamic>(20, 20)));
294  CALL_SUBTEST_3(test_cwise_real(Eigen::Matrix<int16_t, Eigen::Dynamic, Eigen::Dynamic>(20, 20)));
295  CALL_SUBTEST_3(test_cwise_real(Eigen::Matrix<int32_t, Eigen::Dynamic, Eigen::Dynamic>(20, 20)));
296  CALL_SUBTEST_3(test_cwise_real(Eigen::Matrix<int64_t, Eigen::Dynamic, Eigen::Dynamic>(20, 20)));
297  CALL_SUBTEST_4(test_cwise_real(Eigen::Matrix<uint8_t, Eigen::Dynamic, Eigen::Dynamic>(20, 20)));
298  CALL_SUBTEST_4(test_cwise_real(Eigen::Matrix<uint16_t, Eigen::Dynamic, Eigen::Dynamic>(20, 20)));
299  CALL_SUBTEST_4(test_cwise_real(Eigen::Matrix<uint32_t, Eigen::Dynamic, Eigen::Dynamic>(20, 20)));
300  CALL_SUBTEST_4(test_cwise_real(Eigen::Matrix<uint64_t, Eigen::Dynamic, Eigen::Dynamic>(20, 20)));
301  }
302 }
i
int i
Definition: BiCGSTAB_step_by_step.cpp:9
Eigen::Matrix
The matrix class, also used for vectors and row-vectors.
Definition: Eigen/Eigen/src/Core/Matrix.h:186
test_cwise_complex
void test_cwise_complex(const MatrixType &m)
Definition: matrix_cwise.cpp:216
test_cwise_real
void test_cwise_real(const MatrixType &m)
Definition: matrix_cwise.cpp:53
Eigen::g_repeat
static int g_repeat
Definition: main.h:191
Eigen::Dynamic
const int Dynamic
Definition: Constants.h:25
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

References CALL_SUBTEST_1, CALL_SUBTEST_2, CALL_SUBTEST_3, CALL_SUBTEST_4, Eigen::Dynamic, Eigen::g_repeat, i, test_cwise_complex(), and test_cwise_real().

◆ test_cwise_complex()

template<typename MatrixType >
void test_cwise_complex ( const MatrixType &  m)
216  {
217  using Scalar = typename MatrixType::Scalar;
218  using RealScalar = typename NumTraits<Scalar>::Real;
219  Index rows = m.rows();
220  Index cols = m.cols();
221  MatrixType m1 = MatrixType::Random(rows, cols);
222  MatrixType m2, m3, m4;
223 
224  // Supported unary ops.
225  VERIFY_IS_CWISE_APPROX(m1.cwiseAbs(), cwise_ref(m1, [](const Scalar& x) { return Eigen::numext::abs(x); }));
226  VERIFY_IS_CWISE_APPROX(m1.cwiseSqrt(), cwise_ref(m1, [](const Scalar& x) { return Eigen::numext::sqrt(x); }));
227  VERIFY_IS_CWISE_APPROX(m1.cwiseInverse(), cwise_ref(m1, [](const Scalar& x) { return Scalar(Scalar(1) / x); }));
228  VERIFY_IS_CWISE_APPROX(m1.cwiseArg(), cwise_ref(m1, [](const Scalar& x) { return Eigen::numext::arg(x); }));
229  VERIFY_IS_CWISE_APPROX(m1.cwiseCArg(), cwise_ref(m1, [](const Scalar& x) { return Scalar(Eigen::numext::arg(x)); }));
230  // Only find Square/Abs2 of +/- sqrt values so we don't overflow.
231  m2 = m1.cwiseSqrt().array() * m1.cwiseSign().array();
232  VERIFY_IS_CWISE_APPROX(m2.cwiseAbs2(), cwise_ref(m2, [](const Scalar& x) { return Eigen::numext::abs2(x); }));
233  VERIFY_IS_CWISE_APPROX(m2.cwiseSquare(), cwise_ref(m2, [](const Scalar& x) { return Scalar(x * x); }));
234  VERIFY_IS_CWISE_APPROX(m2.cwisePow(Scalar(2)),
235  cwise_ref(m2, [](const Scalar& x) { return Eigen::numext::pow(x, Scalar(2)); }));
236 
237  // Supported binary ops.
238  m1.setRandom(rows, cols);
239  m2.setRandom(rows, cols);
240  VERIFY_IS_CWISE_APPROX(m1.cwiseProduct(m2),
241  cwise_ref(m1, m2, [](const Scalar& x, const Scalar& y) { return Scalar(x * y); }));
242  VERIFY_IS_CWISE_APPROX(m1.cwiseQuotient(m2),
243  cwise_ref(m1, m2, [](const Scalar& x, const Scalar& y) { return Scalar(x / y); }));
244  // For equality comparisons, limit range to increase number of equalities.
245  {
246  const RealScalar kShift = RealScalar(10);
247  m3 = m1;
248  m4 = m2;
249  m3.real() = (m1.real() * kShift).array().floor() / kShift;
250  m3.imag() = (m1.imag() * kShift).array().floor() / kShift;
251  m4.real() = (m2.real() * kShift).array().floor() / kShift;
252  m4.imag() = (m2.imag() * kShift).array().floor() / kShift;
253  }
254  VERIFY_IS_CWISE_EQUAL(m3.cwiseEqual(m4), cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) {
255  return Eigen::numext::equal_strict(x, y);
256  }));
257  VERIFY_IS_CWISE_EQUAL(m3.cwiseNotEqual(m4), cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) {
258  return !Eigen::numext::equal_strict(x, y);
259  }));
260  // Typed-Equality.
261  VERIFY_IS_CWISE_EQUAL(m3.cwiseTypedEqual(m4), cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) {
262  return Eigen::numext::equal_strict(x, y) ? Scalar(1) : Scalar(0);
263  }));
264  VERIFY_IS_CWISE_EQUAL(m3.cwiseTypedNotEqual(m4), cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) {
265  return !Eigen::numext::equal_strict(x, y) ? Scalar(1) : Scalar(0);
266  }));
267  // Scalar.
268  Scalar mean = Scalar(0);
269  m4.setConstant(rows, cols, mean);
270  VERIFY_IS_CWISE_EQUAL(m3.cwiseEqual(mean), cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) {
271  return Eigen::numext::equal_strict(x, y);
272  }));
273  VERIFY_IS_CWISE_EQUAL(m3.cwiseNotEqual(mean), cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) {
274  return !Eigen::numext::equal_strict(x, y);
275  }));
276  // Typed.
277  VERIFY_IS_CWISE_EQUAL(m3.cwiseTypedEqual(mean), cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) {
278  return Eigen::numext::equal_strict(x, y) ? Scalar(1) : Scalar(0);
279  }));
280  VERIFY_IS_CWISE_EQUAL(m3.cwiseTypedNotEqual(mean), cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) {
281  return !Eigen::numext::equal_strict(x, y) ? Scalar(1) : Scalar(0);
282  }));
283 }
rows
int rows
Definition: Tutorial_commainit_02.cpp:1
cols
int cols
Definition: Tutorial_commainit_02.cpp:1
Scalar
SCALAR Scalar
Definition: bench_gemm.cpp:45
RealScalar
NumTraits< Scalar >::Real RealScalar
Definition: bench_gemm.cpp:46
MatrixType
MatrixXf MatrixType
Definition: benchmark-blocking-sizes.cpp:52
y
Scalar * y
Definition: level1_cplx_impl.h:128
VERIFY_IS_CWISE_APPROX
#define VERIFY_IS_CWISE_APPROX(a, b)
Definition: main.h:376
VERIFY_IS_CWISE_EQUAL
#define VERIFY_IS_CWISE_EQUAL(a, b)
Definition: main.h:375
cwise_ref
OutMatrixType cwise_ref(const MatrixType &m, Func f=Func())
Definition: matrix_cwise.cpp:27
Eigen::numext::equal_strict
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool equal_strict(const X &x, const Y &y)
Definition: Meta.h:571
Eigen::numext::abs
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE std::enable_if_t< NumTraits< T >::IsSigned||NumTraits< T >::IsComplex, typename NumTraits< T >::Real > abs(const T &x)
Definition: MathFunctions.h:1355
Eigen::numext::sqrt
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float sqrt(const float &x)
Definition: arch/SSE/MathFunctions.h:69
Eigen::numext::pow
EIGEN_DEVICE_FUNC internal::pow_impl< ScalarX, ScalarY >::result_type pow(const ScalarX &x, const ScalarY &y)
Definition: MathFunctions.h:1161
Eigen::numext::abs2
EIGEN_DEVICE_FUNC bool abs2(bool x)
Definition: MathFunctions.h:1102
Eigen::array
std::array< T, N > array
Definition: EmulateArray.h:231
plotDoE.x
list x
Definition: plotDoE.py:28
Eigen::NumTraits
Holds information about the various numeric (i.e. scalar) types allowed by Eigen.
Definition: NumTraits.h:217

References Eigen::numext::abs(), Eigen::numext::abs2(), cols, cwise_ref(), Eigen::numext::equal_strict(), m, m1, m2(), Eigen::numext::pow(), rows, Eigen::numext::sqrt(), VERIFY_IS_CWISE_APPROX, VERIFY_IS_CWISE_EQUAL, plotDoE::x, and y.

Referenced by EIGEN_DECLARE_TEST().

◆ test_cwise_real()

template<typename MatrixType >
void test_cwise_real ( const MatrixType &  m)
53  {
54  using Scalar = typename MatrixType::Scalar;
55  Index rows = m.rows();
56  Index cols = m.cols();
57  MatrixType m1 = MatrixType::Random(rows, cols);
58  MatrixType m2, m3, m4;
59 
60  // Supported unary ops.
61  VERIFY_IS_CWISE_APPROX(m1.cwiseAbs(), cwise_ref(m1, [](const Scalar& x) { return Eigen::numext::abs(x); }));
62  VERIFY_IS_CWISE_APPROX(m1.cwiseSign(), cwise_ref(m1, [](const Scalar& x) { return Eigen::numext::sign(x); }));
63  VERIFY_IS_CWISE_APPROX(m1.cwiseCbrt(), cwise_ref(m1, [](const Scalar& x) { return Eigen::numext::cbrt(x); }));
64  // For integers, avoid division by zero.
65  m2 = m1;
66  if (Eigen::NumTraits<Scalar>::IsInteger) {
67  m2 = m1.unaryExpr([](const Scalar& x) { return Eigen::numext::equal_strict(x, Scalar(0)) ? Scalar(1) : x; });
68  }
69  VERIFY_IS_CWISE_APPROX(m2.cwiseInverse(), cwise_ref(m2, [](const Scalar& x) { return Scalar(Scalar(1) / x); }));
70  VERIFY_IS_CWISE_APPROX(m1.cwiseArg(), cwise_ref(m1, [](const Scalar& x) { return Eigen::numext::arg(x); }));
71  // Only take sqrt of positive values.
72  m2 = m1.cwiseAbs();
73  VERIFY_IS_CWISE_APPROX(m2.cwiseSqrt(), cwise_ref(m2, [](const Scalar& x) { return Eigen::numext::sqrt(x); }));
74  // Only find Square/Abs2 of +/- sqrt values so we don't overflow.
75  m2 = m2.cwiseSqrt().array() * m1.cwiseSign().array();
76  VERIFY_IS_CWISE_APPROX(m2.cwiseAbs2(), cwise_ref(m2, [](const Scalar& x) { return Eigen::numext::abs2(x); }));
77  VERIFY_IS_CWISE_APPROX(m2.cwiseSquare(), cwise_ref(m2, [](const Scalar& x) { return Scalar(x * x); }));
78  VERIFY_IS_CWISE_APPROX(m2.cwisePow(Scalar(2)),
79  cwise_ref(m2, [](const Scalar& x) { return Eigen::numext::pow(x, Scalar(2)); }));
80 
81  // Supported binary ops.
82  m1.setRandom(rows, cols);
83  m2.setRandom(rows, cols);
84  VERIFY_IS_CWISE_EQUAL(m1.cwiseMin(m2),
85  cwise_ref(m1, m2, [](const Scalar& x, const Scalar& y) { return Eigen::numext::mini(x, y); }));
86  VERIFY_IS_CWISE_EQUAL(m1.template cwiseMin<PropagateFast>(m2),
87  cwise_ref(m1, m2, [](const Scalar& x, const Scalar& y) { return Eigen::numext::mini(x, y); }));
88  VERIFY_IS_CWISE_EQUAL(m1.template cwiseMin<PropagateNaN>(m2),
89  cwise_ref(m1, m2, [](const Scalar& x, const Scalar& y) { return Eigen::numext::mini(x, y); }));
90  VERIFY_IS_CWISE_EQUAL(m1.template cwiseMin<PropagateNumbers>(m2),
91  cwise_ref(m1, m2, [](const Scalar& x, const Scalar& y) { return Eigen::numext::mini(x, y); }));
92  VERIFY_IS_CWISE_EQUAL(m1.cwiseMax(m2),
93  cwise_ref(m1, m2, [](const Scalar& x, const Scalar& y) { return Eigen::numext::maxi(x, y); }));
94  VERIFY_IS_CWISE_EQUAL(m1.template cwiseMax<PropagateFast>(m2),
95  cwise_ref(m1, m2, [](const Scalar& x, const Scalar& y) { return Eigen::numext::maxi(x, y); }));
96  VERIFY_IS_CWISE_EQUAL(m1.template cwiseMax<PropagateNaN>(m2),
97  cwise_ref(m1, m2, [](const Scalar& x, const Scalar& y) { return Eigen::numext::maxi(x, y); }));
98  VERIFY_IS_CWISE_EQUAL(m1.template cwiseMax<PropagateNumbers>(m2),
99  cwise_ref(m1, m2, [](const Scalar& x, const Scalar& y) { return Eigen::numext::maxi(x, y); }));
100  // Scalar comparison.
101  Scalar mean = Eigen::NumTraits<Scalar>::highest() / Scalar(2) + Eigen::NumTraits<Scalar>::lowest() / Scalar(2);
102  m4.setConstant(rows, cols, mean);
103  VERIFY_IS_CWISE_EQUAL(m1.cwiseMin(mean),
104  cwise_ref(m1, m4, [](const Scalar& x, const Scalar& y) { return Eigen::numext::mini(x, y); }));
105  VERIFY_IS_CWISE_EQUAL(m1.template cwiseMin<PropagateFast>(mean),
106  cwise_ref(m1, m4, [](const Scalar& x, const Scalar& y) { return Eigen::numext::mini(x, y); }));
107  VERIFY_IS_CWISE_EQUAL(m1.template cwiseMin<PropagateNaN>(mean),
108  cwise_ref(m1, m4, [](const Scalar& x, const Scalar& y) { return Eigen::numext::mini(x, y); }));
109  VERIFY_IS_CWISE_EQUAL(m1.template cwiseMin<PropagateNumbers>(mean),
110  cwise_ref(m1, m4, [](const Scalar& x, const Scalar& y) { return Eigen::numext::mini(x, y); }));
111  VERIFY_IS_CWISE_EQUAL(m1.cwiseMax(mean),
112  cwise_ref(m1, m4, [](const Scalar& x, const Scalar& y) { return Eigen::numext::maxi(x, y); }));
113  VERIFY_IS_CWISE_EQUAL(m1.template cwiseMax<PropagateFast>(mean),
114  cwise_ref(m1, m4, [](const Scalar& x, const Scalar& y) { return Eigen::numext::maxi(x, y); }));
115  VERIFY_IS_CWISE_EQUAL(m1.template cwiseMax<PropagateNaN>(mean),
116  cwise_ref(m1, m4, [](const Scalar& x, const Scalar& y) { return Eigen::numext::maxi(x, y); }));
117  VERIFY_IS_CWISE_EQUAL(m1.template cwiseMax<PropagateNumbers>(mean),
118  cwise_ref(m1, m4, [](const Scalar& x, const Scalar& y) { return Eigen::numext::maxi(x, y); }));
119  // For products, avoid integer overflow by limiting the input < sqrt(max).
120  m3 = m1;
121  m4 = m2;
122  if (Eigen::NumTraits<Scalar>::IsInteger) {
123  const Scalar kMax = Eigen::numext::sqrt(Eigen::NumTraits<Scalar>::highest());
124  m3 = m1 - ((m1 / kMax) * kMax);
125  m4 = m2 - ((m2 / kMax) * kMax);
126  }
127  VERIFY_IS_CWISE_APPROX(m3.cwiseProduct(m4),
128  cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) { return Scalar(x * y); }));
129  // For quotients involving integers, avoid division by zero.
130  m4 = m2;
131  if (Eigen::NumTraits<Scalar>::IsInteger) {
132  m4 = m2.unaryExpr([](const Scalar& x) { return Eigen::numext::equal_strict(x, Scalar(0)) ? Scalar(1) : x; });
133  }
134  VERIFY_IS_CWISE_APPROX(m1.cwiseQuotient(m4),
135  cwise_ref(m1, m4, [](const Scalar& x, const Scalar& y) { return Scalar(x / y); }));
136  // For equality comparisons, limit range to increase number of equalities.
137  if (Eigen::NumTraits<Scalar>::IsInteger) {
138  const Scalar kMax = Scalar(10);
139  m3 = m1 - ((m1 / kMax) * kMax);
140  m4 = m2 - ((m2 / kMax) * kMax);
141  mean = Eigen::NumTraits<Scalar>::IsSigned ? Scalar(0) : kMax / Scalar(2);
142  } else {
143  const Scalar kShift = Scalar(10);
144  m3 = (m1 * kShift).array().floor() / kShift;
145  m4 = (m2 * kShift).array().floor() / kShift;
146  mean = Scalar(0);
147  }
148  VERIFY_IS_CWISE_EQUAL(m3.cwiseEqual(m4), cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) {
149  return Eigen::numext::equal_strict(x, y);
150  }));
151  VERIFY_IS_CWISE_EQUAL(m3.cwiseNotEqual(m4), cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) {
152  return !Eigen::numext::equal_strict(x, y);
153  }));
154  VERIFY_IS_CWISE_EQUAL(m3.cwiseLess(m4), cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) { return x < y; }));
155  VERIFY_IS_CWISE_EQUAL(m3.cwiseGreater(m4), cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) { return x > y; }));
156  VERIFY_IS_CWISE_EQUAL(m3.cwiseLessOrEqual(m4),
157  cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) { return x <= y; }));
158  VERIFY_IS_CWISE_EQUAL(m3.cwiseGreaterOrEqual(m4),
159  cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) { return x >= y; }));
160  // Typed-Equality.
161  VERIFY_IS_CWISE_EQUAL(m3.cwiseTypedEqual(m4), cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) {
162  return Eigen::numext::equal_strict(x, y) ? Scalar(1) : Scalar(0);
163  }));
164  VERIFY_IS_CWISE_EQUAL(m3.cwiseTypedNotEqual(m4), cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) {
165  return !Eigen::numext::equal_strict(x, y) ? Scalar(1) : Scalar(0);
166  }));
167  VERIFY_IS_CWISE_EQUAL(m3.cwiseTypedLess(m4), cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) {
168  return x < y ? Scalar(1) : Scalar(0);
169  }));
170  VERIFY_IS_CWISE_EQUAL(m3.cwiseTypedGreater(m4), cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) {
171  return x > y ? Scalar(1) : Scalar(0);
172  }));
173  VERIFY_IS_CWISE_EQUAL(m3.cwiseTypedLessOrEqual(m4), cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) {
174  return x <= y ? Scalar(1) : Scalar(0);
175  }));
176  VERIFY_IS_CWISE_EQUAL(m3.cwiseTypedGreaterOrEqual(m4), cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) {
177  return x >= y ? Scalar(1) : Scalar(0);
178  }));
179  // Scalar.
180  m4.setConstant(rows, cols, mean);
181  VERIFY_IS_CWISE_EQUAL(m3.cwiseEqual(mean), cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) {
182  return Eigen::numext::equal_strict(x, y);
183  }));
184  VERIFY_IS_CWISE_EQUAL(m3.cwiseNotEqual(mean), cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) {
185  return !Eigen::numext::equal_strict(x, y);
186  }));
187  VERIFY_IS_CWISE_EQUAL(m3.cwiseLess(mean), cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) { return x < y; }));
188  VERIFY_IS_CWISE_EQUAL(m3.cwiseGreater(mean),
189  cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) { return x > y; }));
190  VERIFY_IS_CWISE_EQUAL(m3.cwiseLessOrEqual(mean),
191  cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) { return x <= y; }));
192  VERIFY_IS_CWISE_EQUAL(m3.cwiseGreaterOrEqual(mean),
193  cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) { return x >= y; }));
194  // Typed.
195  VERIFY_IS_CWISE_EQUAL(m3.cwiseTypedEqual(mean), cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) {
196  return Eigen::numext::equal_strict(x, y) ? Scalar(1) : Scalar(0);
197  }));
198  VERIFY_IS_CWISE_EQUAL(m3.cwiseTypedNotEqual(mean), cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) {
199  return !Eigen::numext::equal_strict(x, y) ? Scalar(1) : Scalar(0);
200  }));
201  VERIFY_IS_CWISE_EQUAL(m3.cwiseTypedLess(mean), cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) {
202  return x < y ? Scalar(1) : Scalar(0);
203  }));
204  VERIFY_IS_CWISE_EQUAL(m3.cwiseTypedGreater(mean), cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) {
205  return x > y ? Scalar(1) : Scalar(0);
206  }));
207  VERIFY_IS_CWISE_EQUAL(m3.cwiseTypedLessOrEqual(mean), cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) {
208  return x <= y ? Scalar(1) : Scalar(0);
209  }));
210  VERIFY_IS_CWISE_EQUAL(m3.cwiseTypedGreaterOrEqual(mean), cwise_ref(m3, m4, [](const Scalar& x, const Scalar& y) {
211  return x >= y ? Scalar(1) : Scalar(0);
212  }));
213 }
Eigen::numext::maxi
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T maxi(const T &x, const T &y)
Definition: MathFunctions.h:926
Eigen::numext::cbrt
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T cbrt(const T &x)
Definition: MathFunctions.h:1320
Eigen::numext::mini
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T mini(const T &x, const T &y)
Definition: MathFunctions.h:920
SYCL::sign
T sign(T x)
Definition: cxx11_tensor_builtins_sycl.cpp:172

References Eigen::numext::abs(), Eigen::numext::abs2(), Eigen::numext::cbrt(), cols, cwise_ref(), Eigen::numext::equal_strict(), m, m1, m2(), Eigen::numext::maxi(), Eigen::numext::mini(), Eigen::numext::pow(), rows, SYCL::sign(), Eigen::numext::sqrt(), VERIFY_IS_CWISE_APPROX, VERIFY_IS_CWISE_EQUAL, plotDoE::x, and y.

Referenced by EIGEN_DECLARE_TEST().