Classes | Namespaces | Functions
visitor.cpp File Reference
#include "main.h"

Classes

struct  TrackedVisitor< Derived, Vectorizable >
 
struct  Eigen::internal::functor_traits< TrackedVisitor< T, Vectorizable > >
 

Namespaces

 Eigen
 Namespace containing all symbols from the Eigen library.
 
 Eigen::internal
 Namespace containing low-level routines from the Eigen library.
 

Functions

template<typename MatrixType >
void matrixVisitor (const MatrixType &p)
 
template<typename VectorType >
void vectorVisitor (const VectorType &w)
 
template<typename Derived , bool Vectorized>
void checkOptimalTraversal_impl (const DenseBase< Derived > &mat)
 
void checkOptimalTraversal ()
 
 EIGEN_DECLARE_TEST (visitor)
 

Function Documentation

◆ checkOptimalTraversal()

void checkOptimalTraversal ( )
266  {
267  using Scalar = float;
268  constexpr int PacketSize = Eigen::internal::packet_traits<Scalar>::size;
269  // use sizes that mix vector and scalar ops
270  constexpr int Rows = 3 * PacketSize + 1;
271  constexpr int Cols = 4 * PacketSize + 1;
272  int rows = internal::random(PacketSize + 1, EIGEN_TEST_MAX_SIZE);
273  int cols = internal::random(PacketSize + 1, EIGEN_TEST_MAX_SIZE);
274 
275  using UnrollColMajor = Matrix<Scalar, Rows, Cols, ColMajor>;
276  using UnrollRowMajor = Matrix<Scalar, Rows, Cols, RowMajor>;
277  using DynamicColMajor = Matrix<Scalar, Dynamic, Dynamic, ColMajor>;
278  using DynamicRowMajor = Matrix<Scalar, Dynamic, Dynamic, RowMajor>;
279 
280  // Scalar-only visitors
281  checkOptimalTraversal_impl<UnrollColMajor, false>(UnrollColMajor(Rows, Cols));
282  checkOptimalTraversal_impl<UnrollRowMajor, false>(UnrollRowMajor(Rows, Cols));
283  checkOptimalTraversal_impl<DynamicColMajor, false>(DynamicColMajor(rows, cols));
284  checkOptimalTraversal_impl<DynamicRowMajor, false>(DynamicRowMajor(rows, cols));
285 
286  // Vectorized visitors
287  checkOptimalTraversal_impl<UnrollColMajor, true>(UnrollColMajor(Rows, Cols));
288  checkOptimalTraversal_impl<UnrollRowMajor, true>(UnrollRowMajor(Rows, Cols));
289  checkOptimalTraversal_impl<DynamicColMajor, true>(DynamicColMajor(rows, cols));
290  checkOptimalTraversal_impl<DynamicRowMajor, true>(DynamicRowMajor(rows, cols));
291 }
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
EIGEN_TEST_MAX_SIZE
#define EIGEN_TEST_MAX_SIZE
Definition: boostmultiprec.cpp:16
Eigen::Matrix
The matrix class, also used for vectors and row-vectors.
Definition: Eigen/Eigen/src/Core/Matrix.h:186
Eigen::internal::packet_traits
Definition: GenericPacketMath.h:108

References cols, EIGEN_TEST_MAX_SIZE, and rows.

Referenced by EIGEN_DECLARE_TEST().

◆ checkOptimalTraversal_impl()

template<typename Derived , bool Vectorized>
void checkOptimalTraversal_impl ( const DenseBase< Derived > &  mat)
241  {
242  using Scalar = typename DenseBase<Derived>::Scalar;
243  static constexpr int PacketSize = Eigen::internal::packet_traits<Scalar>::size;
244  static constexpr bool RowMajor = Derived::IsRowMajor;
245  Derived X(mat.rows(), mat.cols());
246  X.setRandom();
247  TrackedVisitor<Derived, Vectorized> visitor;
248  visitor.visited.reserve(X.size());
249  X.visit(visitor);
250  Index count = 0;
251  for (Index j = 0; j < X.outerSize(); ++j) {
252  for (Index i = 0; i < X.innerSize(); ++i) {
253  Index r = RowMajor ? j : i;
254  Index c = RowMajor ? i : j;
255  VERIFY_IS_EQUAL(visitor.visited[count].first, r);
256  VERIFY_IS_EQUAL(visitor.visited[count].second, c);
257  ++count;
258  }
259  }
260  Index vectorOps = Vectorized ? ((X.innerSize() / PacketSize) * X.outerSize()) : 0;
261  Index scalarOps = X.size() - (vectorOps * PacketSize);
262  VERIFY_IS_EQUAL(vectorOps, visitor.vectorOps);
263  VERIFY_IS_EQUAL(scalarOps, visitor.scalarOps);
264 }
i
int i
Definition: BiCGSTAB_step_by_step.cpp:9
Eigen::DenseBase::Scalar
internal::traits< Derived >::Scalar Scalar
Definition: DenseBase.h:62
Eigen::SparseMatrix::cols
Index cols() const
Definition: SparseMatrix.h:161
Eigen::SparseMatrix::rows
Index rows() const
Definition: SparseMatrix.h:159
Eigen::RowMajor
@ RowMajor
Definition: Constants.h:320
X
#define X
Definition: icosphere.cpp:20
VERIFY_IS_EQUAL
#define VERIFY_IS_EQUAL(a, b)
Definition: main.h:367
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
TrackedVisitor
Definition: visitor.cpp:198
TrackedVisitor::visited
std::vector< std::pair< Index, Index > > visited
Definition: visitor.cpp:224
TrackedVisitor::vectorOps
Index vectorOps
Definition: visitor.cpp:226
TrackedVisitor::scalarOps
Index scalarOps
Definition: visitor.cpp:225
j
std::ptrdiff_t j
Definition: tut_arithmetic_redux_minmax.cpp:2

References calibrate::c, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::cols(), i, j, UniformPSDSelfTest::r, Eigen::RowMajor, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::rows(), TrackedVisitor< Derived, Vectorizable >::scalarOps, TrackedVisitor< Derived, Vectorizable >::vectorOps, VERIFY_IS_EQUAL, TrackedVisitor< Derived, Vectorizable >::visited, and X.

◆ EIGEN_DECLARE_TEST()

EIGEN_DECLARE_TEST ( visitor  )
293  {
294  for (int i = 0; i < g_repeat; i++) {
295  CALL_SUBTEST_1(matrixVisitor(Matrix<float, 1, 1>()));
296  CALL_SUBTEST_2(matrixVisitor(Matrix2f()));
297  CALL_SUBTEST_3(matrixVisitor(Matrix4d()));
298  CALL_SUBTEST_4(matrixVisitor(MatrixXd(8, 12)));
299  CALL_SUBTEST_5(matrixVisitor(Matrix<double, Dynamic, Dynamic, RowMajor>(20, 20)));
300  CALL_SUBTEST_6(matrixVisitor(MatrixXi(8, 12)));
301  }
302  for (int i = 0; i < g_repeat; i++) {
303  CALL_SUBTEST_7(vectorVisitor(Vector4f()));
304  CALL_SUBTEST_7(vectorVisitor(Matrix<int, 12, 1>()));
305  CALL_SUBTEST_8(vectorVisitor(VectorXd(10)));
306  CALL_SUBTEST_9(vectorVisitor(RowVectorXd(10)));
307  CALL_SUBTEST_10(vectorVisitor(VectorXf(33)));
308  }
309  CALL_SUBTEST_11(checkOptimalTraversal());
310 }
Eigen::g_repeat
static int g_repeat
Definition: main.h:191
CALL_SUBTEST_6
#define CALL_SUBTEST_6(FUNC)
Definition: split_test_helper.h:34
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_8
#define CALL_SUBTEST_8(FUNC)
Definition: split_test_helper.h:46
CALL_SUBTEST_5
#define CALL_SUBTEST_5(FUNC)
Definition: split_test_helper.h:28
CALL_SUBTEST_11
#define CALL_SUBTEST_11(FUNC)
Definition: split_test_helper.h:64
CALL_SUBTEST_2
#define CALL_SUBTEST_2(FUNC)
Definition: split_test_helper.h:10
CALL_SUBTEST_7
#define CALL_SUBTEST_7(FUNC)
Definition: split_test_helper.h:40
CALL_SUBTEST_4
#define CALL_SUBTEST_4(FUNC)
Definition: split_test_helper.h:22
CALL_SUBTEST_9
#define CALL_SUBTEST_9(FUNC)
Definition: split_test_helper.h:52
CALL_SUBTEST_10
#define CALL_SUBTEST_10(FUNC)
Definition: split_test_helper.h:58
vectorVisitor
void vectorVisitor(const VectorType &w)
Definition: visitor.cpp:124
checkOptimalTraversal
void checkOptimalTraversal()
Definition: visitor.cpp:266
matrixVisitor
void matrixVisitor(const MatrixType &p)
Definition: visitor.cpp:13

References CALL_SUBTEST_1, CALL_SUBTEST_10, CALL_SUBTEST_11, CALL_SUBTEST_2, CALL_SUBTEST_3, CALL_SUBTEST_4, CALL_SUBTEST_5, CALL_SUBTEST_6, CALL_SUBTEST_7, CALL_SUBTEST_8, CALL_SUBTEST_9, checkOptimalTraversal(), Eigen::g_repeat, i, matrixVisitor(), and vectorVisitor().

◆ matrixVisitor()

template<typename MatrixType >
void matrixVisitor ( const MatrixType &  p)
13  {
14  typedef typename MatrixType::Scalar Scalar;
15 
16  Index rows = p.rows();
17  Index cols = p.cols();
18 
19  // construct a random matrix where all coefficients are different
20  MatrixType m;
21  m = MatrixType::Random(rows, cols);
22  for (Index i = 0; i < m.size(); i++)
23  for (Index i2 = 0; i2 < i; i2++)
24  while (numext::equal_strict(m(i), m(i2))) // yes, strict equality
25  m(i) = internal::random<Scalar>();
26 
27  Scalar minc = Scalar(1000), maxc = Scalar(-1000);
28  Index minrow = 0, mincol = 0, maxrow = 0, maxcol = 0;
29  for (Index j = 0; j < cols; j++)
30  for (Index i = 0; i < rows; i++) {
31  if (m(i, j) < minc) {
32  minc = m(i, j);
33  minrow = i;
34  mincol = j;
35  }
36  if (m(i, j) > maxc) {
37  maxc = m(i, j);
38  maxrow = i;
39  maxcol = j;
40  }
41  }
42  Index eigen_minrow, eigen_mincol, eigen_maxrow, eigen_maxcol;
43  Scalar eigen_minc, eigen_maxc;
44  eigen_minc = m.minCoeff(&eigen_minrow, &eigen_mincol);
45  eigen_maxc = m.maxCoeff(&eigen_maxrow, &eigen_maxcol);
46  VERIFY(minrow == eigen_minrow);
47  VERIFY(maxrow == eigen_maxrow);
48  VERIFY(mincol == eigen_mincol);
49  VERIFY(maxcol == eigen_maxcol);
50  VERIFY_IS_APPROX(minc, eigen_minc);
51  VERIFY_IS_APPROX(maxc, eigen_maxc);
52  VERIFY_IS_APPROX(minc, m.minCoeff());
53  VERIFY_IS_APPROX(maxc, m.maxCoeff());
54 
55  eigen_maxc = (m.adjoint() * m).maxCoeff(&eigen_maxrow, &eigen_maxcol);
56  Index maxrow2 = 0, maxcol2 = 0;
57  eigen_maxc = (m.adjoint() * m).eval().maxCoeff(&maxrow2, &maxcol2);
58  VERIFY(maxrow2 == eigen_maxrow);
59  VERIFY(maxcol2 == eigen_maxcol);
60 
61  if (!NumTraits<Scalar>::IsInteger && m.size() > 2) {
62  // Test NaN propagation by replacing an element with NaN.
63  bool stop = false;
64  for (Index j = 0; j < cols && !stop; ++j) {
65  for (Index i = 0; i < rows && !stop; ++i) {
66  if (!(j == mincol && i == minrow) && !(j == maxcol && i == maxrow)) {
67  m(i, j) = NumTraits<Scalar>::quiet_NaN();
68  stop = true;
69  break;
70  }
71  }
72  }
73 
74  eigen_minc = m.template minCoeff<PropagateNumbers>(&eigen_minrow, &eigen_mincol);
75  eigen_maxc = m.template maxCoeff<PropagateNumbers>(&eigen_maxrow, &eigen_maxcol);
76  VERIFY(minrow == eigen_minrow);
77  VERIFY(maxrow == eigen_maxrow);
78  VERIFY(mincol == eigen_mincol);
79  VERIFY(maxcol == eigen_maxcol);
80  VERIFY_IS_APPROX(minc, eigen_minc);
81  VERIFY_IS_APPROX(maxc, eigen_maxc);
82  VERIFY_IS_APPROX(minc, m.template minCoeff<PropagateNumbers>());
83  VERIFY_IS_APPROX(maxc, m.template maxCoeff<PropagateNumbers>());
84 
85  eigen_minc = m.template minCoeff<PropagateNaN>(&eigen_minrow, &eigen_mincol);
86  eigen_maxc = m.template maxCoeff<PropagateNaN>(&eigen_maxrow, &eigen_maxcol);
87  VERIFY(minrow != eigen_minrow || mincol != eigen_mincol);
88  VERIFY(maxrow != eigen_maxrow || maxcol != eigen_maxcol);
89  VERIFY((numext::isnan)(eigen_minc));
90  VERIFY((numext::isnan)(eigen_maxc));
91 
92  // Test matrix of all NaNs.
93  m.fill(NumTraits<Scalar>::quiet_NaN());
94  eigen_minc = m.template minCoeff<PropagateNumbers>(&eigen_minrow, &eigen_mincol);
95  eigen_maxc = m.template maxCoeff<PropagateNumbers>(&eigen_maxrow, &eigen_maxcol);
96  VERIFY(eigen_minrow == 0);
97  VERIFY(eigen_maxrow == 0);
98  VERIFY(eigen_mincol == 0);
99  VERIFY(eigen_maxcol == 0);
100  VERIFY((numext::isnan)(eigen_minc));
101  VERIFY((numext::isnan)(eigen_maxc));
102 
103  eigen_minc = m.template minCoeff<PropagateNaN>(&eigen_minrow, &eigen_mincol);
104  eigen_maxc = m.template maxCoeff<PropagateNaN>(&eigen_maxrow, &eigen_maxcol);
105  VERIFY(eigen_minrow == 0);
106  VERIFY(eigen_maxrow == 0);
107  VERIFY(eigen_mincol == 0);
108  VERIFY(eigen_maxcol == 0);
109  VERIFY((numext::isnan)(eigen_minc));
110  VERIFY((numext::isnan)(eigen_maxc));
111 
112  eigen_minc = m.template minCoeff<PropagateFast>(&eigen_minrow, &eigen_mincol);
113  eigen_maxc = m.template maxCoeff<PropagateFast>(&eigen_maxrow, &eigen_maxcol);
114  VERIFY(eigen_minrow == 0);
115  VERIFY(eigen_maxrow == 0);
116  VERIFY(eigen_mincol == 0);
117  VERIFY(eigen_maxcol == 0);
118  VERIFY((numext::isnan)(eigen_minc));
119  VERIFY((numext::isnan)(eigen_maxc));
120  }
121 }
p
float * p
Definition: Tutorial_Map_using.cpp:9
MatrixType
MatrixXf MatrixType
Definition: benchmark-blocking-sizes.cpp:52
VERIFY_IS_APPROX
#define VERIFY_IS_APPROX(a, b)
Definition: integer_types.cpp:13
m
int * m
Definition: level2_cplx_impl.h:294
VERIFY
#define VERIFY(a)
Definition: main.h:362
isnan
#define isnan(X)
Definition: main.h:109
Eigen::numext::equal_strict
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool equal_strict(const X &x, const Y &y)
Definition: Meta.h:571
eval
internal::nested_eval< T, 1 >::type eval(const T &xpr)
Definition: sparse_permutations.cpp:47
Eigen::NumTraits
Holds information about the various numeric (i.e. scalar) types allowed by Eigen.
Definition: NumTraits.h:217

References cols, Eigen::numext::equal_strict(), eval(), i, isnan, j, m, p, rows, VERIFY, and VERIFY_IS_APPROX.

Referenced by EIGEN_DECLARE_TEST().

◆ vectorVisitor()

template<typename VectorType >
void vectorVisitor ( const VectorType &  w)
124  {
125  typedef typename VectorType::Scalar Scalar;
126 
127  Index size = w.size();
128 
129  // construct a random vector where all coefficients are different
130  VectorType v;
131  v = VectorType::Random(size);
132  for (Index i = 0; i < size; i++)
133  for (Index i2 = 0; i2 < i; i2++)
134  while (v(i) == v(i2)) // yes, ==
135  v(i) = internal::random<Scalar>();
136 
137  Scalar minc = v(0), maxc = v(0);
138  Index minidx = 0, maxidx = 0;
139  for (Index i = 0; i < size; i++) {
140  if (v(i) < minc) {
141  minc = v(i);
142  minidx = i;
143  }
144  if (v(i) > maxc) {
145  maxc = v(i);
146  maxidx = i;
147  }
148  }
149  Index eigen_minidx, eigen_maxidx;
150  Scalar eigen_minc, eigen_maxc;
151  eigen_minc = v.minCoeff(&eigen_minidx);
152  eigen_maxc = v.maxCoeff(&eigen_maxidx);
153  VERIFY(minidx == eigen_minidx);
154  VERIFY(maxidx == eigen_maxidx);
155  VERIFY_IS_APPROX(minc, eigen_minc);
156  VERIFY_IS_APPROX(maxc, eigen_maxc);
157  VERIFY_IS_APPROX(minc, v.minCoeff());
158  VERIFY_IS_APPROX(maxc, v.maxCoeff());
159 
160  Index idx0 = internal::random<Index>(0, size - 1);
161  Index idx1 = eigen_minidx;
162  Index idx2 = eigen_maxidx;
163  VectorType v1(v), v2(v);
164  v1(idx0) = v1(idx1);
165  v2(idx0) = v2(idx2);
166  v1.minCoeff(&eigen_minidx);
167  v2.maxCoeff(&eigen_maxidx);
168  VERIFY(eigen_minidx == (std::min)(idx0, idx1));
169  VERIFY(eigen_maxidx == (std::min)(idx0, idx2));
170 
171  if (!NumTraits<Scalar>::IsInteger && size > 2) {
172  // Test NaN propagation by replacing an element with NaN.
173  for (Index i = 0; i < size; ++i) {
174  if (i != minidx && i != maxidx) {
175  v(i) = NumTraits<Scalar>::quiet_NaN();
176  break;
177  }
178  }
179  eigen_minc = v.template minCoeff<PropagateNumbers>(&eigen_minidx);
180  eigen_maxc = v.template maxCoeff<PropagateNumbers>(&eigen_maxidx);
181  VERIFY(minidx == eigen_minidx);
182  VERIFY(maxidx == eigen_maxidx);
183  VERIFY_IS_APPROX(minc, eigen_minc);
184  VERIFY_IS_APPROX(maxc, eigen_maxc);
185  VERIFY_IS_APPROX(minc, v.template minCoeff<PropagateNumbers>());
186  VERIFY_IS_APPROX(maxc, v.template maxCoeff<PropagateNumbers>());
187 
188  eigen_minc = v.template minCoeff<PropagateNaN>(&eigen_minidx);
189  eigen_maxc = v.template maxCoeff<PropagateNaN>(&eigen_maxidx);
190  VERIFY(minidx != eigen_minidx);
191  VERIFY(maxidx != eigen_maxidx);
192  VERIFY((numext::isnan)(eigen_minc));
193  VERIFY((numext::isnan)(eigen_maxc));
194  }
195 }
v
Array< int, Dynamic, 1 > v
Definition: Array_initializer_list_vector_cxx11.cpp:1
w
RowVector3d w
Definition: Matrix_resize_int.cpp:3
v2
Map< RowVectorXf > v2(M2.data(), M2.size())
v1
M1<< 1, 2, 3, 4, 5, 6, 7, 8, 9;Map< RowVectorXf > v1(M1.data(), M1.size())
size
Scalar Scalar int size
Definition: benchVecAdd.cpp:17
min
#define min(a, b)
Definition: datatypes.h:22
VectorType
Definition: fft_test_shared.h:66

References i, isnan, min, size, v, v1(), v2(), VERIFY, VERIFY_IS_APPROX, and w.

Referenced by EIGEN_DECLARE_TEST().