Functions
cxx11_tensor_index_list.cpp File Reference
#include "main.h"
#include <Eigen/CXX11/Tensor>

Functions

static void test_static_index_list ()
 
static void test_type2index_list ()
 
static void test_type2indexpair_list ()
 
static void test_dynamic_index_list ()
 
static void test_mixed_index_list ()
 
static void test_dim_check ()
 
 EIGEN_DECLARE_TEST (cxx11_tensor_index_list)
 

Function Documentation

◆ EIGEN_DECLARE_TEST()

EIGEN_DECLARE_TEST ( cxx11_tensor_index_list  )
417  {
418  CALL_SUBTEST(test_static_index_list());
419  CALL_SUBTEST(test_type2index_list());
420  CALL_SUBTEST(test_type2indexpair_list());
421  CALL_SUBTEST(test_dynamic_index_list());
422  CALL_SUBTEST(test_mixed_index_list());
423  CALL_SUBTEST(test_dim_check());
424 }
test_type2indexpair_list
static void test_type2indexpair_list()
Definition: cxx11_tensor_index_list.cpp:171
test_type2index_list
static void test_type2index_list()
Definition: cxx11_tensor_index_list.cpp:46
test_mixed_index_list
static void test_mixed_index_list()
Definition: cxx11_tensor_index_list.cpp:346
test_dynamic_index_list
static void test_dynamic_index_list()
Definition: cxx11_tensor_index_list.cpp:315
test_dim_check
static void test_dim_check()
Definition: cxx11_tensor_index_list.cpp:409
test_static_index_list
static void test_static_index_list()
Definition: cxx11_tensor_index_list.cpp:14
CALL_SUBTEST
#define CALL_SUBTEST(FUNC)
Definition: main.h:382

References CALL_SUBTEST, test_dim_check(), test_dynamic_index_list(), test_mixed_index_list(), test_static_index_list(), test_type2index_list(), and test_type2indexpair_list().

◆ test_dim_check()

static void test_dim_check ( )
static
409  {
410  Eigen::IndexList<Eigen::type2index<1>, int> dim1;
411  dim1.set(1, 2);
412  Eigen::IndexList<Eigen::type2index<1>, int> dim2;
413  dim2.set(1, 2);
414  VERIFY(dimensions_match(dim1, dim2));
415 }
VERIFY
#define VERIFY(a)
Definition: main.h:362
Eigen::dimensions_match
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool dimensions_match(Dims1 dims1, Dims2 dims2)
Definition: TensorDimensions.h:322
Eigen::IndexList
Definition: TensorIndexList.h:271
Eigen::IndexList::set
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC void set(const Index i, const Index value)
Definition: TensorIndexList.h:280

References Eigen::dimensions_match(), Eigen::IndexList< FirstType, OtherTypes >::set(), and VERIFY.

Referenced by EIGEN_DECLARE_TEST().

◆ test_dynamic_index_list()

static void test_dynamic_index_list ( )
static
315  {
316  Tensor<float, 4> tensor(2, 3, 5, 7);
317  tensor.setRandom();
318 
319  int dim1 = 2;
320  int dim2 = 1;
321  int dim3 = 0;
322 
323  auto reduction_axis = make_index_list(dim1, dim2, dim3);
324 
325  VERIFY_IS_EQUAL(internal::array_get<0>(reduction_axis), 2);
326  VERIFY_IS_EQUAL(internal::array_get<1>(reduction_axis), 1);
327  VERIFY_IS_EQUAL(internal::array_get<2>(reduction_axis), 0);
328  VERIFY_IS_EQUAL(static_cast<Index>(reduction_axis[0]), 2);
329  VERIFY_IS_EQUAL(static_cast<Index>(reduction_axis[1]), 1);
330  VERIFY_IS_EQUAL(static_cast<Index>(reduction_axis[2]), 0);
331 
332  Tensor<float, 1> result = tensor.sum(reduction_axis);
333  for (int i = 0; i < result.size(); ++i) {
334  float expected = 0.0f;
335  for (int j = 0; j < 2; ++j) {
336  for (int k = 0; k < 3; ++k) {
337  for (int l = 0; l < 5; ++l) {
338  expected += tensor(j, k, l, i);
339  }
340  }
341  }
342  VERIFY_IS_APPROX(result(i), expected);
343  }
344 }
i
int i
Definition: BiCGSTAB_step_by_step.cpp:9
Eigen::Tensor
The tensor class.
Definition: Tensor.h:68
Eigen::Tensor::size
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index size() const
Definition: Tensor.h:101
VERIFY_IS_APPROX
#define VERIFY_IS_APPROX(a, b)
Definition: integer_types.cpp:13
k
char char char int int * k
Definition: level2_impl.h:374
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
Eigen::make_index_list
constexpr IndexList< FirstType, OtherTypes... > make_index_list(FirstType val1, OtherTypes... other_vals)
Definition: TensorIndexList.h:320
j
std::ptrdiff_t j
Definition: tut_arithmetic_redux_minmax.cpp:2

References i, j, k, Eigen::make_index_list(), Eigen::TensorBase< Derived, AccessLevel >::setRandom(), Eigen::Tensor< Scalar_, NumIndices_, Options_, IndexType_ >::size(), VERIFY_IS_APPROX, and VERIFY_IS_EQUAL.

Referenced by EIGEN_DECLARE_TEST().

◆ test_mixed_index_list()

static void test_mixed_index_list ( )
static
346  {
347  Tensor<float, 4> tensor(2, 3, 5, 7);
348  tensor.setRandom();
349 
350  int dim2 = 1;
351  int dim4 = 3;
352 
353  auto reduction_axis = make_index_list(0, dim2, 2, dim4);
354 
355  VERIFY_IS_EQUAL(internal::array_get<0>(reduction_axis), 0);
356  VERIFY_IS_EQUAL(internal::array_get<1>(reduction_axis), 1);
357  VERIFY_IS_EQUAL(internal::array_get<2>(reduction_axis), 2);
358  VERIFY_IS_EQUAL(internal::array_get<3>(reduction_axis), 3);
359  VERIFY_IS_EQUAL(static_cast<Index>(reduction_axis[0]), 0);
360  VERIFY_IS_EQUAL(static_cast<Index>(reduction_axis[1]), 1);
361  VERIFY_IS_EQUAL(static_cast<Index>(reduction_axis[2]), 2);
362  VERIFY_IS_EQUAL(static_cast<Index>(reduction_axis[3]), 3);
363 
364  typedef IndexList<type2index<0>, int, type2index<2>, int> ReductionIndices;
365  ReductionIndices reduction_indices;
366  reduction_indices.set(1, 1);
367  reduction_indices.set(3, 3);
368  EIGEN_STATIC_ASSERT((internal::array_get<0>(reduction_indices) == 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
369  EIGEN_STATIC_ASSERT((internal::array_get<2>(reduction_indices) == 2), YOU_MADE_A_PROGRAMMING_MISTAKE);
370  EIGEN_STATIC_ASSERT((internal::index_known_statically<ReductionIndices>(0) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
371  EIGEN_STATIC_ASSERT((internal::index_known_statically<ReductionIndices>(2) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
372  EIGEN_STATIC_ASSERT((internal::index_statically_eq<ReductionIndices>(0, 0) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
373  EIGEN_STATIC_ASSERT((internal::index_statically_eq<ReductionIndices>(2, 2) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
374 #if 0
375  EIGEN_STATIC_ASSERT((internal::all_indices_known_statically<ReductionIndices>() == false), YOU_MADE_A_PROGRAMMING_MISTAKE);
376  EIGEN_STATIC_ASSERT((internal::indices_statically_known_to_increase<ReductionIndices>() == false), YOU_MADE_A_PROGRAMMING_MISTAKE);
377 #endif
378 
379  typedef IndexList<type2index<0>, type2index<1>, type2index<2>, type2index<3>> ReductionList;
380  ReductionList reduction_list;
381  EIGEN_STATIC_ASSERT((internal::index_statically_eq<ReductionList>(0, 0) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
382  EIGEN_STATIC_ASSERT((internal::index_statically_eq<ReductionList>(1, 1) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
383  EIGEN_STATIC_ASSERT((internal::index_statically_eq<ReductionList>(2, 2) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
384  EIGEN_STATIC_ASSERT((internal::index_statically_eq<ReductionList>(3, 3) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
385 #if 0
386  EIGEN_STATIC_ASSERT((internal::all_indices_known_statically<ReductionList>() == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
387  EIGEN_STATIC_ASSERT((internal::indices_statically_known_to_increase<ReductionList>() == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
388 #endif
389 
390  Tensor<float, 0> result1 = tensor.sum(reduction_axis);
391  Tensor<float, 0> result2 = tensor.sum(reduction_indices);
392  Tensor<float, 0> result3 = tensor.sum(reduction_list);
393 
394  float expected = 0.0f;
395  for (int i = 0; i < 2; ++i) {
396  for (int j = 0; j < 3; ++j) {
397  for (int k = 0; k < 5; ++k) {
398  for (int l = 0; l < 7; ++l) {
399  expected += tensor(i, j, k, l);
400  }
401  }
402  }
403  }
404  VERIFY_IS_APPROX(result1(), expected);
405  VERIFY_IS_APPROX(result2(), expected);
406  VERIFY_IS_APPROX(result3(), expected);
407 }
EIGEN_STATIC_ASSERT
#define EIGEN_STATIC_ASSERT(X, MSG)
Definition: StaticAssert.h:26
int
return int(ret)+1
Eigen::type2index
Definition: TensorIndexList.h:39
Eigen::type2index::set
EIGEN_DEVICE_FUNC void set(Index val)
Definition: TensorIndexList.h:42

References EIGEN_STATIC_ASSERT, i, int(), j, k, Eigen::make_index_list(), Eigen::type2index< n >::set(), Eigen::TensorBase< Derived, AccessLevel >::setRandom(), VERIFY_IS_APPROX, and VERIFY_IS_EQUAL.

Referenced by EIGEN_DECLARE_TEST().

◆ test_static_index_list()

static void test_static_index_list ( )
static
14  {
15  Tensor<float, 4> tensor(2, 3, 5, 7);
16  tensor.setRandom();
17 
18  constexpr auto reduction_axis = make_index_list(0, 1, 2);
19  VERIFY_IS_EQUAL(internal::array_get<0>(reduction_axis), 0);
20  VERIFY_IS_EQUAL(internal::array_get<1>(reduction_axis), 1);
21  VERIFY_IS_EQUAL(internal::array_get<2>(reduction_axis), 2);
22  VERIFY_IS_EQUAL(static_cast<Index>(reduction_axis[0]), 0);
23  VERIFY_IS_EQUAL(static_cast<Index>(reduction_axis[1]), 1);
24  VERIFY_IS_EQUAL(static_cast<Index>(reduction_axis[2]), 2);
25 
26  VERIFY_IS_EQUAL(reduction_axis.size(), std::size_t(3));
27 
28  EIGEN_STATIC_ASSERT((internal::array_get<0>(reduction_axis) == 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
29  EIGEN_STATIC_ASSERT((internal::array_get<1>(reduction_axis) == 1), YOU_MADE_A_PROGRAMMING_MISTAKE);
30  EIGEN_STATIC_ASSERT((internal::array_get<2>(reduction_axis) == 2), YOU_MADE_A_PROGRAMMING_MISTAKE);
31 
32  Tensor<float, 1> result = tensor.sum(reduction_axis);
33  for (int i = 0; i < result.size(); ++i) {
34  float expected = 0.0f;
35  for (int j = 0; j < 2; ++j) {
36  for (int k = 0; k < 3; ++k) {
37  for (int l = 0; l < 5; ++l) {
38  expected += tensor(j, k, l, i);
39  }
40  }
41  }
42  VERIFY_IS_APPROX(result(i), expected);
43  }
44 }

References EIGEN_STATIC_ASSERT, i, j, k, Eigen::make_index_list(), Eigen::TensorBase< Derived, AccessLevel >::setRandom(), Eigen::Tensor< Scalar_, NumIndices_, Options_, IndexType_ >::size(), VERIFY_IS_APPROX, and VERIFY_IS_EQUAL.

Referenced by EIGEN_DECLARE_TEST().

◆ test_type2index_list()

static void test_type2index_list ( )
static
46  {
47  Tensor<float, 5> tensor(2, 3, 5, 7, 11);
48  tensor.setRandom();
49  tensor += tensor.constant(10.0f);
50 
51  typedef Eigen::IndexList<Eigen::type2index<0>> Dims0;
52  typedef Eigen::IndexList<Eigen::type2index<0>, Eigen::type2index<1>> Dims1;
53  typedef Eigen::IndexList<Eigen::type2index<0>, Eigen::type2index<1>, Eigen::type2index<2>> Dims2;
54  typedef Eigen::IndexList<Eigen::type2index<0>, Eigen::type2index<1>, Eigen::type2index<2>, Eigen::type2index<3>>
55  Dims3;
56  typedef Eigen::IndexList<Eigen::type2index<0>, Eigen::type2index<1>, Eigen::type2index<2>, Eigen::type2index<3>,
57  Eigen::type2index<4>>
58  Dims4;
59 
60 #if 0
61  EIGEN_STATIC_ASSERT((internal::indices_statically_known_to_increase<Dims0>() == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
62  EIGEN_STATIC_ASSERT((internal::indices_statically_known_to_increase<Dims1>() == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
63  EIGEN_STATIC_ASSERT((internal::indices_statically_known_to_increase<Dims2>() == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
64  EIGEN_STATIC_ASSERT((internal::indices_statically_known_to_increase<Dims3>() == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
65  EIGEN_STATIC_ASSERT((internal::indices_statically_known_to_increase<Dims4>() == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
66 #endif
67 
68  EIGEN_STATIC_ASSERT((internal::are_inner_most_dims<Dims0, 1, ColMajor>::value == true),
69  YOU_MADE_A_PROGRAMMING_MISTAKE);
70  EIGEN_STATIC_ASSERT((internal::are_inner_most_dims<Dims1, 2, ColMajor>::value == true),
71  YOU_MADE_A_PROGRAMMING_MISTAKE);
72  EIGEN_STATIC_ASSERT((internal::are_inner_most_dims<Dims2, 3, ColMajor>::value == true),
73  YOU_MADE_A_PROGRAMMING_MISTAKE);
74  EIGEN_STATIC_ASSERT((internal::are_inner_most_dims<Dims3, 4, ColMajor>::value == true),
75  YOU_MADE_A_PROGRAMMING_MISTAKE);
76  EIGEN_STATIC_ASSERT((internal::are_inner_most_dims<Dims4, 5, ColMajor>::value == true),
77  YOU_MADE_A_PROGRAMMING_MISTAKE);
78 
79  EIGEN_STATIC_ASSERT((internal::are_inner_most_dims<Dims0, 1, RowMajor>::value == true),
80  YOU_MADE_A_PROGRAMMING_MISTAKE);
81  EIGEN_STATIC_ASSERT((internal::are_inner_most_dims<Dims1, 2, RowMajor>::value == true),
82  YOU_MADE_A_PROGRAMMING_MISTAKE);
83  EIGEN_STATIC_ASSERT((internal::are_inner_most_dims<Dims2, 3, RowMajor>::value == true),
84  YOU_MADE_A_PROGRAMMING_MISTAKE);
85  EIGEN_STATIC_ASSERT((internal::are_inner_most_dims<Dims3, 4, RowMajor>::value == true),
86  YOU_MADE_A_PROGRAMMING_MISTAKE);
87  EIGEN_STATIC_ASSERT((internal::are_inner_most_dims<Dims4, 5, RowMajor>::value == true),
88  YOU_MADE_A_PROGRAMMING_MISTAKE);
89 
90  const Dims0 reduction_axis0;
91  Tensor<float, 4> result0 = tensor.sum(reduction_axis0);
92  for (int m = 0; m < 11; ++m) {
93  for (int l = 0; l < 7; ++l) {
94  for (int k = 0; k < 5; ++k) {
95  for (int j = 0; j < 3; ++j) {
96  float expected = 0.0f;
97  for (int i = 0; i < 2; ++i) {
98  expected += tensor(i, j, k, l, m);
99  }
100  VERIFY_IS_APPROX(result0(j, k, l, m), expected);
101  }
102  }
103  }
104  }
105 
106  const Dims1 reduction_axis1;
107  Tensor<float, 3> result1 = tensor.sum(reduction_axis1);
108  for (int m = 0; m < 11; ++m) {
109  for (int l = 0; l < 7; ++l) {
110  for (int k = 0; k < 5; ++k) {
111  float expected = 0.0f;
112  for (int j = 0; j < 3; ++j) {
113  for (int i = 0; i < 2; ++i) {
114  expected += tensor(i, j, k, l, m);
115  }
116  }
117  VERIFY_IS_APPROX(result1(k, l, m), expected);
118  }
119  }
120  }
121 
122  const Dims2 reduction_axis2;
123  Tensor<float, 2> result2 = tensor.sum(reduction_axis2);
124  for (int m = 0; m < 11; ++m) {
125  for (int l = 0; l < 7; ++l) {
126  float expected = 0.0f;
127  for (int k = 0; k < 5; ++k) {
128  for (int j = 0; j < 3; ++j) {
129  for (int i = 0; i < 2; ++i) {
130  expected += tensor(i, j, k, l, m);
131  }
132  }
133  }
134  VERIFY_IS_APPROX(result2(l, m), expected);
135  }
136  }
137 
138  const Dims3 reduction_axis3;
139  Tensor<float, 1> result3 = tensor.sum(reduction_axis3);
140  for (int m = 0; m < 11; ++m) {
141  float expected = 0.0f;
142  for (int l = 0; l < 7; ++l) {
143  for (int k = 0; k < 5; ++k) {
144  for (int j = 0; j < 3; ++j) {
145  for (int i = 0; i < 2; ++i) {
146  expected += tensor(i, j, k, l, m);
147  }
148  }
149  }
150  }
151  VERIFY_IS_APPROX(result3(m), expected);
152  }
153 
154  const Dims4 reduction_axis4;
155  Tensor<float, 0> result4 = tensor.sum(reduction_axis4);
156  float expected = 0.0f;
157  for (int m = 0; m < 11; ++m) {
158  for (int l = 0; l < 7; ++l) {
159  for (int k = 0; k < 5; ++k) {
160  for (int j = 0; j < 3; ++j) {
161  for (int i = 0; i < 2; ++i) {
162  expected += tensor(i, j, k, l, m);
163  }
164  }
165  }
166  }
167  }
168  VERIFY_IS_APPROX(result4(), expected);
169 }
m
int * m
Definition: level2_cplx_impl.h:294
Eigen::value
squared absolute value
Definition: GlobalFunctions.h:87

References EIGEN_STATIC_ASSERT, i, j, k, m, Eigen::TensorBase< Derived, AccessLevel >::setRandom(), Eigen::value, and VERIFY_IS_APPROX.

Referenced by EIGEN_DECLARE_TEST().

◆ test_type2indexpair_list()

static void test_type2indexpair_list ( )
static
171  {
172  Tensor<float, 5> tensor(2, 3, 5, 7, 11);
173  tensor.setRandom();
174  tensor += tensor.constant(10.0f);
175 
176  typedef Eigen::IndexPairList<Eigen::type2indexpair<0, 10>> Dims0;
177  typedef Eigen::IndexPairList<Eigen::type2indexpair<0, 10>, Eigen::type2indexpair<1, 11>, Eigen::type2indexpair<2, 12>>
178  Dims2_a;
179  typedef Eigen::IndexPairList<Eigen::type2indexpair<0, 10>, Eigen::IndexPair<Index>, Eigen::type2indexpair<2, 12>>
180  Dims2_b;
181  typedef Eigen::IndexPairList<Eigen::IndexPair<Index>, Eigen::type2indexpair<1, 11>, Eigen::IndexPair<Index>> Dims2_c;
182 
183  Dims2_a d2_a;
184 
185  Dims2_b d2_b;
186  d2_b.set(1, Eigen::IndexPair<Index>(1, 11));
187 
188  Dims2_c d2_c;
189  d2_c.set(0, Eigen::IndexPair<Index>(Eigen::IndexPair<Index>(0, 10)));
190  d2_c.set(1, Eigen::IndexPair<Index>(1, 11)); // setting type2indexpair to correct value.
191  d2_c.set(2, Eigen::IndexPair<Index>(2, 12));
192 
193  VERIFY_IS_EQUAL(d2_a[0].first, 0);
194  VERIFY_IS_EQUAL(d2_a[0].second, 10);
195  VERIFY_IS_EQUAL(d2_a[1].first, 1);
196  VERIFY_IS_EQUAL(d2_a[1].second, 11);
197  VERIFY_IS_EQUAL(d2_a[2].first, 2);
198  VERIFY_IS_EQUAL(d2_a[2].second, 12);
199 
200  VERIFY_IS_EQUAL(d2_b[0].first, 0);
201  VERIFY_IS_EQUAL(d2_b[0].second, 10);
202  VERIFY_IS_EQUAL(d2_b[1].first, 1);
203  VERIFY_IS_EQUAL(d2_b[1].second, 11);
204  VERIFY_IS_EQUAL(d2_b[2].first, 2);
205  VERIFY_IS_EQUAL(d2_b[2].second, 12);
206 
207  VERIFY_IS_EQUAL(d2_c[0].first, 0);
208  VERIFY_IS_EQUAL(d2_c[0].second, 10);
209  VERIFY_IS_EQUAL(d2_c[1].first, 1);
210  VERIFY_IS_EQUAL(d2_c[1].second, 11);
211  VERIFY_IS_EQUAL(d2_c[2].first, 2);
212  VERIFY_IS_EQUAL(d2_c[2].second, 12);
213 
214  EIGEN_STATIC_ASSERT((d2_a.value_known_statically(0) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
215  EIGEN_STATIC_ASSERT((d2_a.value_known_statically(1) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
216  EIGEN_STATIC_ASSERT((d2_a.value_known_statically(2) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
217 
218  EIGEN_STATIC_ASSERT((d2_b.value_known_statically(0) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
219  EIGEN_STATIC_ASSERT((d2_b.value_known_statically(1) == false), YOU_MADE_A_PROGRAMMING_MISTAKE);
220  EIGEN_STATIC_ASSERT((d2_b.value_known_statically(2) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
221 
222  EIGEN_STATIC_ASSERT((d2_c.value_known_statically(0) == false), YOU_MADE_A_PROGRAMMING_MISTAKE);
223  EIGEN_STATIC_ASSERT((d2_c.value_known_statically(1) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
224  EIGEN_STATIC_ASSERT((d2_c.value_known_statically(2) == false), YOU_MADE_A_PROGRAMMING_MISTAKE);
225 
226  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims0>(0, 0) == true),
227  YOU_MADE_A_PROGRAMMING_MISTAKE);
228  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims0>(0, 1) == false),
229  YOU_MADE_A_PROGRAMMING_MISTAKE);
230 
231  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_a>(0, 0) == true),
232  YOU_MADE_A_PROGRAMMING_MISTAKE);
233  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_a>(0, 1) == false),
234  YOU_MADE_A_PROGRAMMING_MISTAKE);
235  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_a>(1, 1) == true),
236  YOU_MADE_A_PROGRAMMING_MISTAKE);
237  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_a>(1, 2) == false),
238  YOU_MADE_A_PROGRAMMING_MISTAKE);
239  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_a>(2, 2) == true),
240  YOU_MADE_A_PROGRAMMING_MISTAKE);
241  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_a>(2, 3) == false),
242  YOU_MADE_A_PROGRAMMING_MISTAKE);
243 
244  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_b>(0, 0) == true),
245  YOU_MADE_A_PROGRAMMING_MISTAKE);
246  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_b>(0, 1) == false),
247  YOU_MADE_A_PROGRAMMING_MISTAKE);
248  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_b>(1, 1) == false),
249  YOU_MADE_A_PROGRAMMING_MISTAKE);
250  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_b>(1, 2) == false),
251  YOU_MADE_A_PROGRAMMING_MISTAKE);
252  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_b>(2, 2) == true),
253  YOU_MADE_A_PROGRAMMING_MISTAKE);
254  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_b>(2, 3) == false),
255  YOU_MADE_A_PROGRAMMING_MISTAKE);
256 
257  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_c>(0, 0) == false),
258  YOU_MADE_A_PROGRAMMING_MISTAKE);
259  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_c>(0, 1) == false),
260  YOU_MADE_A_PROGRAMMING_MISTAKE);
261  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_c>(1, 1) == true),
262  YOU_MADE_A_PROGRAMMING_MISTAKE);
263  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_c>(1, 2) == false),
264  YOU_MADE_A_PROGRAMMING_MISTAKE);
265  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_c>(2, 2) == false),
266  YOU_MADE_A_PROGRAMMING_MISTAKE);
267  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_c>(2, 3) == false),
268  YOU_MADE_A_PROGRAMMING_MISTAKE);
269 
270  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims0>(0, 10) == true),
271  YOU_MADE_A_PROGRAMMING_MISTAKE);
272  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims0>(0, 11) == false),
273  YOU_MADE_A_PROGRAMMING_MISTAKE);
274 
275  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_a>(0, 10) == true),
276  YOU_MADE_A_PROGRAMMING_MISTAKE);
277  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_a>(0, 11) == false),
278  YOU_MADE_A_PROGRAMMING_MISTAKE);
279  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_a>(1, 11) == true),
280  YOU_MADE_A_PROGRAMMING_MISTAKE);
281  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_a>(1, 12) == false),
282  YOU_MADE_A_PROGRAMMING_MISTAKE);
283  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_a>(2, 12) == true),
284  YOU_MADE_A_PROGRAMMING_MISTAKE);
285  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_a>(2, 13) == false),
286  YOU_MADE_A_PROGRAMMING_MISTAKE);
287 
288  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_b>(0, 10) == true),
289  YOU_MADE_A_PROGRAMMING_MISTAKE);
290  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_b>(0, 11) == false),
291  YOU_MADE_A_PROGRAMMING_MISTAKE);
292  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_b>(1, 11) == false),
293  YOU_MADE_A_PROGRAMMING_MISTAKE);
294  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_b>(1, 12) == false),
295  YOU_MADE_A_PROGRAMMING_MISTAKE);
296  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_b>(2, 12) == true),
297  YOU_MADE_A_PROGRAMMING_MISTAKE);
298  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_b>(2, 13) == false),
299  YOU_MADE_A_PROGRAMMING_MISTAKE);
300 
301  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_c>(0, 10) == false),
302  YOU_MADE_A_PROGRAMMING_MISTAKE);
303  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_c>(0, 11) == false),
304  YOU_MADE_A_PROGRAMMING_MISTAKE);
305  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_c>(1, 11) == true),
306  YOU_MADE_A_PROGRAMMING_MISTAKE);
307  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_c>(1, 12) == false),
308  YOU_MADE_A_PROGRAMMING_MISTAKE);
309  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_c>(2, 12) == false),
310  YOU_MADE_A_PROGRAMMING_MISTAKE);
311  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_c>(2, 13) == false),
312  YOU_MADE_A_PROGRAMMING_MISTAKE);
313 }
Eigen::IndexPairList
Definition: TensorIndexList.h:325
Eigen::IndexPair
Definition: TensorMeta.h:238
Eigen::IndexPair::set
EIGEN_DEVICE_FUNC void set(IndexPair< Idx > val)
Definition: TensorMeta.h:242
Eigen::type2indexpair
Definition: TensorIndexList.h:48

References EIGEN_STATIC_ASSERT, Eigen::IndexPair< Idx >::set(), Eigen::TensorBase< Derived, AccessLevel >::setRandom(), and VERIFY_IS_EQUAL.

Referenced by EIGEN_DECLARE_TEST().