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

Functions

template<int DataLayout>
static void test_simple_chip ()
 
template<int DataLayout>
static void test_dynamic_chip ()
 
template<int DataLayout>
static void test_chip_in_expr ()
 
template<int DataLayout>
static void test_chip_as_lvalue ()
 
static void test_chip_raw_data_col_major ()
 
static void test_chip_raw_data_row_major ()
 
 EIGEN_DECLARE_TEST (cxx11_tensor_chipping)
 

Function Documentation

◆ EIGEN_DECLARE_TEST()

EIGEN_DECLARE_TEST ( cxx11_tensor_chipping  )
408  {
409  CALL_SUBTEST(test_simple_chip<ColMajor>());
410  CALL_SUBTEST(test_simple_chip<RowMajor>());
411  CALL_SUBTEST(test_dynamic_chip<ColMajor>());
412  CALL_SUBTEST(test_dynamic_chip<RowMajor>());
413  CALL_SUBTEST(test_chip_in_expr<ColMajor>());
414  CALL_SUBTEST(test_chip_in_expr<RowMajor>());
415  CALL_SUBTEST(test_chip_as_lvalue<ColMajor>());
416  CALL_SUBTEST(test_chip_as_lvalue<RowMajor>());
417  CALL_SUBTEST(test_chip_raw_data_col_major());
418  CALL_SUBTEST(test_chip_raw_data_row_major());
419 }
test_chip_raw_data_col_major
static void test_chip_raw_data_col_major()
Definition: cxx11_tensor_chipping.cpp:340
test_chip_raw_data_row_major
static void test_chip_raw_data_row_major()
Definition: cxx11_tensor_chipping.cpp:374
CALL_SUBTEST
#define CALL_SUBTEST(FUNC)
Definition: main.h:382

References CALL_SUBTEST, test_chip_raw_data_col_major(), and test_chip_raw_data_row_major().

◆ test_chip_as_lvalue()

template<int DataLayout>
static void test_chip_as_lvalue ( )
static
215  {
216  Tensor<float, 5, DataLayout> input1(2, 3, 5, 7, 11);
217  input1.setRandom();
218 
219  Tensor<float, 4, DataLayout> input2(3, 5, 7, 11);
220  input2.setRandom();
221  Tensor<float, 5, DataLayout> tensor = input1;
222  tensor.template chip<0>(1) = input2;
223  for (int i = 0; i < 2; ++i) {
224  for (int j = 0; j < 3; ++j) {
225  for (int k = 0; k < 5; ++k) {
226  for (int l = 0; l < 7; ++l) {
227  for (int m = 0; m < 11; ++m) {
228  if (i != 1) {
229  VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input1(i, j, k, l, m));
230  } else {
231  VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input2(j, k, l, m));
232  }
233  }
234  }
235  }
236  }
237  }
238 
239  Tensor<float, 4, DataLayout> input3(2, 5, 7, 11);
240  input3.setRandom();
241  tensor = input1;
242  tensor.template chip<1>(1) = input3;
243  for (int i = 0; i < 2; ++i) {
244  for (int j = 0; j < 3; ++j) {
245  for (int k = 0; k < 5; ++k) {
246  for (int l = 0; l < 7; ++l) {
247  for (int m = 0; m < 11; ++m) {
248  if (j != 1) {
249  VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input1(i, j, k, l, m));
250  } else {
251  VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input3(i, k, l, m));
252  }
253  }
254  }
255  }
256  }
257  }
258 
259  Tensor<float, 4, DataLayout> input4(2, 3, 7, 11);
260  input4.setRandom();
261  tensor = input1;
262  tensor.template chip<2>(3) = input4;
263  for (int i = 0; i < 2; ++i) {
264  for (int j = 0; j < 3; ++j) {
265  for (int k = 0; k < 5; ++k) {
266  for (int l = 0; l < 7; ++l) {
267  for (int m = 0; m < 11; ++m) {
268  if (k != 3) {
269  VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input1(i, j, k, l, m));
270  } else {
271  VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input4(i, j, l, m));
272  }
273  }
274  }
275  }
276  }
277  }
278 
279  Tensor<float, 4, DataLayout> input5(2, 3, 5, 11);
280  input5.setRandom();
281  tensor = input1;
282  tensor.template chip<3>(4) = input5;
283  for (int i = 0; i < 2; ++i) {
284  for (int j = 0; j < 3; ++j) {
285  for (int k = 0; k < 5; ++k) {
286  for (int l = 0; l < 7; ++l) {
287  for (int m = 0; m < 11; ++m) {
288  if (l != 4) {
289  VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input1(i, j, k, l, m));
290  } else {
291  VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input5(i, j, k, m));
292  }
293  }
294  }
295  }
296  }
297  }
298 
299  Tensor<float, 4, DataLayout> input6(2, 3, 5, 7);
300  input6.setRandom();
301  tensor = input1;
302  tensor.template chip<4>(5) = input6;
303  for (int i = 0; i < 2; ++i) {
304  for (int j = 0; j < 3; ++j) {
305  for (int k = 0; k < 5; ++k) {
306  for (int l = 0; l < 7; ++l) {
307  for (int m = 0; m < 11; ++m) {
308  if (m != 5) {
309  VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input1(i, j, k, l, m));
310  } else {
311  VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input6(i, j, k, l));
312  }
313  }
314  }
315  }
316  }
317  }
318 
319  Tensor<float, 5, DataLayout> input7(2, 3, 5, 7, 11);
320  input7.setRandom();
321  tensor = input1;
322  tensor.chip(0, 0) = input7.chip(0, 0);
323  for (int i = 0; i < 2; ++i) {
324  for (int j = 0; j < 3; ++j) {
325  for (int k = 0; k < 5; ++k) {
326  for (int l = 0; l < 7; ++l) {
327  for (int m = 0; m < 11; ++m) {
328  if (i != 0) {
329  VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input1(i, j, k, l, m));
330  } else {
331  VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input7(i, j, k, l, m));
332  }
333  }
334  }
335  }
336  }
337  }
338 }
i
int i
Definition: BiCGSTAB_step_by_step.cpp:9
Eigen::TensorBase::chip
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const TensorChippingOp< DimId, const Derived > chip(const Index offset) const
Definition: TensorBase.h:1141
Eigen::Tensor
The tensor class.
Definition: Tensor.h:68
m
int * m
Definition: level2_cplx_impl.h:294
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
j
std::ptrdiff_t j
Definition: tut_arithmetic_redux_minmax.cpp:2

References Eigen::TensorBase< Derived, AccessLevel >::chip(), i, j, k, m, Eigen::TensorBase< Derived, AccessLevel >::setRandom(), and VERIFY_IS_EQUAL.

◆ test_chip_in_expr()

template<int DataLayout>
static void test_chip_in_expr ( )
static
183  {
184  Tensor<float, 5, DataLayout> input1(2, 3, 5, 7, 11);
185  input1.setRandom();
186  Tensor<float, 4, DataLayout> input2(3, 5, 7, 11);
187  input2.setRandom();
188 
189  Tensor<float, 4, DataLayout> result = input1.template chip<0>(0) + input2;
190  for (int i = 0; i < 3; ++i) {
191  for (int j = 0; j < 5; ++j) {
192  for (int k = 0; k < 7; ++k) {
193  for (int l = 0; l < 11; ++l) {
194  float expected = input1(0, i, j, k, l) + input2(i, j, k, l);
195  VERIFY_IS_EQUAL(result(i, j, k, l), expected);
196  }
197  }
198  }
199  }
200 
201  Tensor<float, 3, DataLayout> input3(3, 7, 11);
202  input3.setRandom();
203  Tensor<float, 3, DataLayout> result2 = input1.template chip<0>(0).template chip<1>(2) + input3;
204  for (int i = 0; i < 3; ++i) {
205  for (int j = 0; j < 7; ++j) {
206  for (int k = 0; k < 11; ++k) {
207  float expected = input1(0, i, 2, j, k) + input3(i, j, k);
208  VERIFY_IS_EQUAL(result2(i, j, k), expected);
209  }
210  }
211  }
212 }

References i, j, k, Eigen::TensorBase< Derived, AccessLevel >::setRandom(), and VERIFY_IS_EQUAL.

◆ test_chip_raw_data_col_major()

static void test_chip_raw_data_col_major ( )
static
340  {
341  Tensor<float, 5, ColMajor> tensor(2, 3, 5, 7, 11);
342  tensor.setRandom();
343 
344  typedef TensorEvaluator<decltype(tensor.chip<4>(3)), DefaultDevice> Evaluator4;
345  auto chip = Evaluator4(tensor.chip<4>(3), DefaultDevice());
346  for (int i = 0; i < 2; ++i) {
347  for (int j = 0; j < 3; ++j) {
348  for (int k = 0; k < 5; ++k) {
349  for (int l = 0; l < 7; ++l) {
350  int chip_index = i + 2 * (j + 3 * (k + 5 * l));
351  VERIFY_IS_EQUAL(chip.data()[chip_index], tensor(i, j, k, l, 3));
352  }
353  }
354  }
355  }
356 
357  typedef TensorEvaluator<decltype(tensor.chip<0>(0)), DefaultDevice> Evaluator0;
358  auto chip0 = Evaluator0(tensor.chip<0>(0), DefaultDevice());
359  VERIFY_IS_EQUAL(chip0.data(), static_cast<float*>(0));
360 
361  typedef TensorEvaluator<decltype(tensor.chip<1>(0)), DefaultDevice> Evaluator1;
362  auto chip1 = Evaluator1(tensor.chip<1>(0), DefaultDevice());
363  VERIFY_IS_EQUAL(chip1.data(), static_cast<float*>(0));
364 
365  typedef TensorEvaluator<decltype(tensor.chip<2>(0)), DefaultDevice> Evaluator2;
366  auto chip2 = Evaluator2(tensor.chip<2>(0), DefaultDevice());
367  VERIFY_IS_EQUAL(chip2.data(), static_cast<float*>(0));
368 
369  typedef TensorEvaluator<decltype(tensor.chip<3>(0)), DefaultDevice> Evaluator3;
370  auto chip3 = Evaluator3(tensor.chip<3>(0), DefaultDevice());
371  VERIFY_IS_EQUAL(chip3.data(), static_cast<float*>(0));
372 }
Eigen::DefaultDevice
Definition: TensorDeviceDefault.h:19
Eigen::TensorEvaluator
A cost model used to limit the number of threads used for evaluating tensor expression.
Definition: TensorEvaluator.h:31

References Eigen::TensorBase< Derived, AccessLevel >::chip(), i, j, k, Eigen::TensorBase< Derived, AccessLevel >::setRandom(), and VERIFY_IS_EQUAL.

Referenced by EIGEN_DECLARE_TEST().

◆ test_chip_raw_data_row_major()

static void test_chip_raw_data_row_major ( )
static
374  {
375  Tensor<float, 5, RowMajor> tensor(11, 7, 5, 3, 2);
376  tensor.setRandom();
377 
378  typedef TensorEvaluator<decltype(tensor.chip<0>(3)), DefaultDevice> Evaluator0;
379  auto chip = Evaluator0(tensor.chip<0>(3), DefaultDevice());
380  for (int i = 0; i < 7; ++i) {
381  for (int j = 0; j < 5; ++j) {
382  for (int k = 0; k < 3; ++k) {
383  for (int l = 0; l < 2; ++l) {
384  int chip_index = l + 2 * (k + 3 * (j + 5 * i));
385  VERIFY_IS_EQUAL(chip.data()[chip_index], tensor(3, i, j, k, l));
386  }
387  }
388  }
389  }
390 
391  typedef TensorEvaluator<decltype(tensor.chip<1>(0)), DefaultDevice> Evaluator1;
392  auto chip1 = Evaluator1(tensor.chip<1>(0), DefaultDevice());
393  VERIFY_IS_EQUAL(chip1.data(), static_cast<float*>(0));
394 
395  typedef TensorEvaluator<decltype(tensor.chip<2>(0)), DefaultDevice> Evaluator2;
396  auto chip2 = Evaluator2(tensor.chip<2>(0), DefaultDevice());
397  VERIFY_IS_EQUAL(chip2.data(), static_cast<float*>(0));
398 
399  typedef TensorEvaluator<decltype(tensor.chip<3>(0)), DefaultDevice> Evaluator3;
400  auto chip3 = Evaluator3(tensor.chip<3>(0), DefaultDevice());
401  VERIFY_IS_EQUAL(chip3.data(), static_cast<float*>(0));
402 
403  typedef TensorEvaluator<decltype(tensor.chip<4>(0)), DefaultDevice> Evaluator4;
404  auto chip4 = Evaluator4(tensor.chip<4>(0), DefaultDevice());
405  VERIFY_IS_EQUAL(chip4.data(), static_cast<float*>(0));
406 }

References Eigen::TensorBase< Derived, AccessLevel >::chip(), i, j, k, Eigen::TensorBase< Derived, AccessLevel >::setRandom(), and VERIFY_IS_EQUAL.

Referenced by EIGEN_DECLARE_TEST().

◆ test_dynamic_chip()

template<int DataLayout>
static void test_dynamic_chip ( )
static
101  {
102  Tensor<float, 5, DataLayout> tensor(2, 3, 5, 7, 11);
103  tensor.setRandom();
104 
105  Tensor<float, 4, DataLayout> chip1;
106  chip1 = tensor.chip(1, 0);
107  VERIFY_IS_EQUAL(chip1.dimension(0), 3);
108  VERIFY_IS_EQUAL(chip1.dimension(1), 5);
109  VERIFY_IS_EQUAL(chip1.dimension(2), 7);
110  VERIFY_IS_EQUAL(chip1.dimension(3), 11);
111  for (int i = 0; i < 3; ++i) {
112  for (int j = 0; j < 5; ++j) {
113  for (int k = 0; k < 7; ++k) {
114  for (int l = 0; l < 11; ++l) {
115  VERIFY_IS_EQUAL(chip1(i, j, k, l), tensor(1, i, j, k, l));
116  }
117  }
118  }
119  }
120 
121  Tensor<float, 4, DataLayout> chip2 = tensor.chip(1, 1);
122  VERIFY_IS_EQUAL(chip2.dimension(0), 2);
123  VERIFY_IS_EQUAL(chip2.dimension(1), 5);
124  VERIFY_IS_EQUAL(chip2.dimension(2), 7);
125  VERIFY_IS_EQUAL(chip2.dimension(3), 11);
126  for (int i = 0; i < 2; ++i) {
127  for (int j = 0; j < 5; ++j) {
128  for (int k = 0; k < 7; ++k) {
129  for (int l = 0; l < 11; ++l) {
130  VERIFY_IS_EQUAL(chip2(i, j, k, l), tensor(i, 1, j, k, l));
131  }
132  }
133  }
134  }
135 
136  Tensor<float, 4, DataLayout> chip3 = tensor.chip(2, 2);
137  VERIFY_IS_EQUAL(chip3.dimension(0), 2);
138  VERIFY_IS_EQUAL(chip3.dimension(1), 3);
139  VERIFY_IS_EQUAL(chip3.dimension(2), 7);
140  VERIFY_IS_EQUAL(chip3.dimension(3), 11);
141  for (int i = 0; i < 2; ++i) {
142  for (int j = 0; j < 3; ++j) {
143  for (int k = 0; k < 7; ++k) {
144  for (int l = 0; l < 11; ++l) {
145  VERIFY_IS_EQUAL(chip3(i, j, k, l), tensor(i, j, 2, k, l));
146  }
147  }
148  }
149  }
150 
151  Tensor<float, 4, DataLayout> chip4(tensor.chip(5, 3));
152  VERIFY_IS_EQUAL(chip4.dimension(0), 2);
153  VERIFY_IS_EQUAL(chip4.dimension(1), 3);
154  VERIFY_IS_EQUAL(chip4.dimension(2), 5);
155  VERIFY_IS_EQUAL(chip4.dimension(3), 11);
156  for (int i = 0; i < 2; ++i) {
157  for (int j = 0; j < 3; ++j) {
158  for (int k = 0; k < 5; ++k) {
159  for (int l = 0; l < 11; ++l) {
160  VERIFY_IS_EQUAL(chip4(i, j, k, l), tensor(i, j, k, 5, l));
161  }
162  }
163  }
164  }
165 
166  Tensor<float, 4, DataLayout> chip5(tensor.chip(7, 4));
167  VERIFY_IS_EQUAL(chip5.dimension(0), 2);
168  VERIFY_IS_EQUAL(chip5.dimension(1), 3);
169  VERIFY_IS_EQUAL(chip5.dimension(2), 5);
170  VERIFY_IS_EQUAL(chip5.dimension(3), 7);
171  for (int i = 0; i < 2; ++i) {
172  for (int j = 0; j < 3; ++j) {
173  for (int k = 0; k < 5; ++k) {
174  for (int l = 0; l < 7; ++l) {
175  VERIFY_IS_EQUAL(chip5(i, j, k, l), tensor(i, j, k, l, 7));
176  }
177  }
178  }
179  }
180 }
Eigen::Tensor::dimension
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index dimension(std::size_t n) const
Definition: Tensor.h:99

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

◆ test_simple_chip()

template<int DataLayout>
static void test_simple_chip ( )
static
17  {
18  Tensor<float, 5, DataLayout> tensor(2, 3, 5, 7, 11);
19  tensor.setRandom();
20 
21  Tensor<float, 4, DataLayout> chip1;
22  chip1 = tensor.template chip<0>(1);
23 
24  VERIFY_IS_EQUAL(chip1.dimension(0), 3);
25  VERIFY_IS_EQUAL(chip1.dimension(1), 5);
26  VERIFY_IS_EQUAL(chip1.dimension(2), 7);
27  VERIFY_IS_EQUAL(chip1.dimension(3), 11);
28 
29  for (int i = 0; i < 3; ++i) {
30  for (int j = 0; j < 5; ++j) {
31  for (int k = 0; k < 7; ++k) {
32  for (int l = 0; l < 11; ++l) {
33  VERIFY_IS_EQUAL(chip1(i, j, k, l), tensor(1, i, j, k, l));
34  }
35  }
36  }
37  }
38 
39  Tensor<float, 4, DataLayout> chip2 = tensor.template chip<1>(1);
40  VERIFY_IS_EQUAL(chip2.dimension(0), 2);
41  VERIFY_IS_EQUAL(chip2.dimension(1), 5);
42  VERIFY_IS_EQUAL(chip2.dimension(2), 7);
43  VERIFY_IS_EQUAL(chip2.dimension(3), 11);
44  for (int i = 0; i < 2; ++i) {
45  for (int j = 0; j < 5; ++j) {
46  for (int k = 0; k < 7; ++k) {
47  for (int l = 0; l < 11; ++l) {
48  VERIFY_IS_EQUAL(chip2(i, j, k, l), tensor(i, 1, j, k, l));
49  }
50  }
51  }
52  }
53 
54  Tensor<float, 4, DataLayout> chip3 = tensor.template chip<2>(2);
55  VERIFY_IS_EQUAL(chip3.dimension(0), 2);
56  VERIFY_IS_EQUAL(chip3.dimension(1), 3);
57  VERIFY_IS_EQUAL(chip3.dimension(2), 7);
58  VERIFY_IS_EQUAL(chip3.dimension(3), 11);
59  for (int i = 0; i < 2; ++i) {
60  for (int j = 0; j < 3; ++j) {
61  for (int k = 0; k < 7; ++k) {
62  for (int l = 0; l < 11; ++l) {
63  VERIFY_IS_EQUAL(chip3(i, j, k, l), tensor(i, j, 2, k, l));
64  }
65  }
66  }
67  }
68 
69  Tensor<float, 4, DataLayout> chip4(tensor.template chip<3>(5));
70  VERIFY_IS_EQUAL(chip4.dimension(0), 2);
71  VERIFY_IS_EQUAL(chip4.dimension(1), 3);
72  VERIFY_IS_EQUAL(chip4.dimension(2), 5);
73  VERIFY_IS_EQUAL(chip4.dimension(3), 11);
74  for (int i = 0; i < 2; ++i) {
75  for (int j = 0; j < 3; ++j) {
76  for (int k = 0; k < 5; ++k) {
77  for (int l = 0; l < 11; ++l) {
78  VERIFY_IS_EQUAL(chip4(i, j, k, l), tensor(i, j, k, 5, l));
79  }
80  }
81  }
82  }
83 
84  Tensor<float, 4, DataLayout> chip5(tensor.template chip<4>(7));
85  VERIFY_IS_EQUAL(chip5.dimension(0), 2);
86  VERIFY_IS_EQUAL(chip5.dimension(1), 3);
87  VERIFY_IS_EQUAL(chip5.dimension(2), 5);
88  VERIFY_IS_EQUAL(chip5.dimension(3), 7);
89  for (int i = 0; i < 2; ++i) {
90  for (int j = 0; j < 3; ++j) {
91  for (int k = 0; k < 5; ++k) {
92  for (int l = 0; l < 7; ++l) {
93  VERIFY_IS_EQUAL(chip5(i, j, k, l), tensor(i, j, k, l, 7));
94  }
95  }
96  }
97  }
98 }

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