1 #include "gtest/gtest.h"
2 #include "indexed_varray.hpp"
3
4 using namespace std;
5 using namespace MArray;
6
7 #define CHECK_INDEXED_VARRAY_RESET(v) \
8 EXPECT_EQ(0u, v.dimension()); \
9 EXPECT_EQ(0u, v.dense_dimension()); \
10 EXPECT_EQ(0u, v.indexed_dimension()); \
11 EXPECT_EQ(0u, v.num_indices()); \
12 EXPECT_EQ(0u, v.data().size());
13
14 #define CHECK_INDEXED_VARRAY(v,value,...) \
15 EXPECT_EQ(4u, v.dimension()); \
16 EXPECT_EQ(2u, v.dense_dimension()); \
17 EXPECT_EQ(2u, v.indexed_dimension()); \
18 EXPECT_EQ((len_vector{4, 2, 5, 4}), v.lengths()); \
19 EXPECT_EQ((len_vector{4, 2}), v.dense_lengths()); \
20 EXPECT_EQ((len_vector{5, 4}), v.indexed_lengths()); \
21 EXPECT_EQ((stride_vector __VA_ARGS__), v.dense_strides()); \
22 EXPECT_EQ(3u, v.num_indices()); \
23 EXPECT_EQ((matrix<len_type>{{0, 0}, {2, 1}, {4, 3}}), v.indices()); \
24 EXPECT_EQ(value, v.data(0)[0]);
25
TEST(indexed_varray,constructor)26 TEST(indexed_varray, constructor)
27 {
28 indexed_varray<double> v1;
29 CHECK_INDEXED_VARRAY_RESET(v1)
30
31 indexed_varray<double> v2({4, 2, 5, 4}, {{0, 0}, {2, 1}, {4, 3}});
32 CHECK_INDEXED_VARRAY(v2, 0.0, {2, 1})
33
34 indexed_varray<double> v3(vector<char>{4, 2, 5, 4}, vector<array<char,2>>{{0, 0}, {2, 1}, {4, 3}});
35 CHECK_INDEXED_VARRAY(v3, 0.0, {2, 1})
36
37 indexed_varray<double> v21({4, 2, 5, 4}, {{0, 0}, {2, 1}, {4, 3}}, 1.0);
38 CHECK_INDEXED_VARRAY(v21, 1.0, {2, 1})
39
40 indexed_varray<double> v31(vector<char>{4, 2, 5, 4}, vector<array<char,2>>{{0, 0}, {2, 1}, {4, 3}}, 1.0);
41 CHECK_INDEXED_VARRAY(v31, 1.0, {2, 1})
42
43 indexed_varray<double> v4({4, 2, 5, 4}, {{0, 0}, {2, 1}, {4, 3}}, 1.0, COLUMN_MAJOR);
44 CHECK_INDEXED_VARRAY(v4, 1.0, {1, 4})
45
46 indexed_varray<double> v41({4, 2, 5, 4}, {{0, 0}, {2, 1}, {4, 3}}, COLUMN_MAJOR);
47 CHECK_INDEXED_VARRAY(v41, 0.0, {1, 4})
48
49 indexed_varray<double> v5(v21.view());
50 CHECK_INDEXED_VARRAY(v5, 1.0, {2, 1})
51
52 indexed_varray<double> v52(v21.cview());
53 CHECK_INDEXED_VARRAY(v52, 1.0, {2, 1})
54
55 indexed_varray<double> v51(v21);
56 CHECK_INDEXED_VARRAY(v51, 1.0, {2, 1})
57
58 indexed_varray<double> v6(indexed_varray<double>({4, 2, 5, 4}, {{0, 0}, {2, 1}, {4, 3}}));
59 CHECK_INDEXED_VARRAY(v6, 0.0, {2, 1})
60
61 indexed_varray<double> v61(indexed_varray<double>({4, 2, 5, 4}, {{0, 0}, {2, 1}, {4, 3}}, COLUMN_MAJOR));
62 CHECK_INDEXED_VARRAY(v61, 0.0, {1, 4})
63
64 indexed_varray<double> v62(indexed_varray<double>({4, 2, 5, 4}, {{0, 0}, {2, 1}, {4, 3}}), COLUMN_MAJOR);
65 CHECK_INDEXED_VARRAY(v62, 0.0, {1, 4})
66 }
67
TEST(indexed_varray,reset)68 TEST(indexed_varray, reset)
69 {
70 indexed_varray<double> v2({4, 2, 5, 4}, {{0, 0}, {2, 1}, {4, 3}}, 1.0);
71
72 indexed_varray<double> v1;
73 CHECK_INDEXED_VARRAY_RESET(v1)
74
75 v1.reset({4, 2, 5, 4}, {{0, 0}, {2, 1}, {4, 3}});
76 CHECK_INDEXED_VARRAY(v1, 0.0, {2, 1})
77
78 v1.reset(vector<char>{4, 2, 5, 4}, vector<array<char,2>>{{0, 0}, {2, 1}, {4, 3}});
79 CHECK_INDEXED_VARRAY(v1, 0.0, {2, 1})
80
81 v1.reset({4, 2, 5, 4}, {{0, 0}, {2, 1}, {4, 3}}, 1.0);
82 CHECK_INDEXED_VARRAY(v1, 1.0, {2, 1})
83
84 v1.reset(vector<char>{4, 2, 5, 4}, vector<array<char,2>>{{0, 0}, {2, 1}, {4, 3}}, 1.0);
85 CHECK_INDEXED_VARRAY(v1, 1.0, {2, 1})
86
87 v1.reset({4, 2, 5, 4}, {{0, 0}, {2, 1}, {4, 3}}, 1.0, COLUMN_MAJOR);
88 CHECK_INDEXED_VARRAY(v1, 1.0, {1, 4})
89
90 v1.reset({4, 2, 5, 4}, {{0, 0}, {2, 1}, {4, 3}}, COLUMN_MAJOR);
91 CHECK_INDEXED_VARRAY(v1, 0.0, {1, 4})
92
93 v1.reset(v2.view());
94 CHECK_INDEXED_VARRAY(v1, 1.0, {2, 1})
95
96 v1.reset(v2.cview());
97 CHECK_INDEXED_VARRAY(v1, 1.0, {2, 1})
98
99 v1.reset(v2);
100 CHECK_INDEXED_VARRAY(v1, 1.0, {2, 1})
101
102 v1.reset(indexed_varray<double>({4, 2, 5, 4}, {{0, 0}, {2, 1}, {4, 3}}));
103 CHECK_INDEXED_VARRAY(v1, 0.0, {2, 1})
104
105 v1.reset(indexed_varray<double>({4, 2, 5, 4}, {{0, 0}, {2, 1}, {4, 3}}, COLUMN_MAJOR));
106 CHECK_INDEXED_VARRAY(v1, 0.0, {1, 4})
107
108 v1.reset(indexed_varray<double>({4, 2, 5, 4}, {{0, 0}, {2, 1}, {4, 3}}), COLUMN_MAJOR);
109 CHECK_INDEXED_VARRAY(v1, 0.0, {1, 4})
110
111 v1.reset();
112 CHECK_INDEXED_VARRAY_RESET(v1)
113 }
114
TEST(indexed_varray,view)115 TEST(indexed_varray, view)
116 {
117 indexed_varray<double> v1({4, 2, 5, 4}, {{0, 0}, {2, 1}, {4, 3}}, 1.0);
118
119 auto v2 = v1.cview();
120 CHECK_INDEXED_VARRAY(v2, 1.0, {2, 1});
121
122 auto v3 = v1.view();
123 CHECK_INDEXED_VARRAY(v3, 1.0, {2, 1});
124
125 auto v4 = const_cast<const indexed_varray<double>&>(v1).view();
126 CHECK_INDEXED_VARRAY(v4, 1.0, {2, 1});
127 }
128
TEST(indexed_varray,access)129 TEST(indexed_varray, access)
130 {
131 indexed_varray<double> v1({4, 2, 5, 4}, {{0, 0}, {2, 1}, {4, 3}});
132
133 auto v2 = v1[0];
134 EXPECT_EQ((len_vector{4, 2}), v2.lengths());
135 EXPECT_EQ((stride_vector{2, 1}), v2.strides());
136 EXPECT_EQ(v1.data(0), v2.data());
137
138 auto v3 = const_cast<const indexed_varray<double>&>(v1)[2];
139 EXPECT_EQ((len_vector{4, 2}), v3.lengths());
140 EXPECT_EQ((stride_vector{2, 1}), v3.strides());
141 EXPECT_EQ(v1.data(2), v3.data());
142 }
143
TEST(indexed_varray,index_iteration)144 TEST(indexed_varray, index_iteration)
145 {
146 int indices[3][2] = {{0, 0}, {2, 1}, {4, 3}};
147 array<int,3> visited;
148
149 indexed_varray<double> v1({4, 2, 5, 4}, {{0, 0}, {2, 1}, {4, 3}});
150 const indexed_varray<double> v2(v1);
151
152 visited = {};
153 v1.for_each_index(
154 [&](const varray_view<double>& v, const index_vector& idx)
155 {
156 EXPECT_EQ(idx.size(), 2u);
157 len_type i = idx[0];
158 len_type j = idx[1];
159 bool found = false;
160 for (int m = 0;m < 3;m++)
161 {
162 if (i == indices[m][0] && j == indices[m][1])
163 {
164 EXPECT_EQ(v1.data(m), v.data());
165 found = true;
166 visited[m]++;
167 }
168 }
169 EXPECT_TRUE(found);
170 EXPECT_EQ((len_vector{4, 2}), v.lengths());
171 EXPECT_EQ((stride_vector{2, 1}), v.strides());
172 });
173
174 for (len_type i = 0;i < 3;i++)
175 {
176 EXPECT_EQ(visited[i], 1);
177 }
178
179 visited = {};
180 v2.for_each_index(
181 [&](const varray_view<const double>& v, const index_vector& idx)
182 {
183 EXPECT_EQ(idx.size(), 2u);
184 len_type i = idx[0];
185 len_type j = idx[1];
186 bool found = false;
187 for (int m = 0;m < 3;m++)
188 {
189 if (i == indices[m][0] && j == indices[m][1])
190 {
191 EXPECT_EQ(v2.data(m), v.data());
192 found = true;
193 visited[m]++;
194 }
195 }
196 EXPECT_TRUE(found);
197 EXPECT_EQ((len_vector{4, 2}), v.lengths());
198 EXPECT_EQ((stride_vector{2, 1}), v.strides());
199 });
200
201 for (len_type i = 0;i < 3;i++)
202 {
203 EXPECT_EQ(visited[i], 1);
204 }
205
206 visited = {};
207 v1.for_each_index<2,2>(
208 [&](const marray_view<double,2>& v, len_type i, len_type j)
209 {
210 bool found = false;
211 for (int m = 0;m < 3;m++)
212 {
213 if (i == indices[m][0] && j == indices[m][1])
214 {
215 EXPECT_EQ(v1.data(m), v.data());
216 found = true;
217 visited[m]++;
218 }
219 }
220 EXPECT_TRUE(found);
221 EXPECT_EQ((array<len_type,2>{4, 2}), v.lengths());
222 EXPECT_EQ((array<stride_type,2>{2, 1}), v.strides());
223 });
224
225 for (len_type i = 0;i < 3;i++)
226 {
227 EXPECT_EQ(visited[i], 1);
228 }
229
230 visited = {};
231 v2.for_each_index<2,2>(
232 [&](const marray_view<const double,2>& v, len_type i, len_type j)
233 {
234 bool found = false;
235 for (int m = 0;m < 3;m++)
236 {
237 if (i == indices[m][0] && j == indices[m][1])
238 {
239 EXPECT_EQ(v2.data(m), v.data());
240 found = true;
241 visited[m]++;
242 }
243 }
244 EXPECT_TRUE(found);
245 EXPECT_EQ((array<len_type,2>{4, 2}), v.lengths());
246 EXPECT_EQ((array<stride_type,2>{2, 1}), v.strides());
247 });
248
249 for (len_type i = 0;i < 3;i++)
250 {
251 EXPECT_EQ(visited[i], 1);
252 }
253 }
254
TEST(indexed_varray,element_iteration)255 TEST(indexed_varray, element_iteration)
256 {
257 int indices[3][2] = {{0, 0}, {2, 1}, {4, 3}};
258 array<array<array<int,3>,2>,4> visited;
259
260 indexed_varray<double> v1({4, 2, 5, 4}, {{0, 0}, {2, 1}, {4, 3}});
261 const indexed_varray<double> v2(v1);
262
263 visited = {};
264 v1.for_each_element(
265 [&](double& v, const len_vector& idx)
266 {
267 EXPECT_EQ(idx.size(), 4u);
268 len_type i = idx[0];
269 len_type j = idx[1];
270 len_type k = idx[2];
271 len_type l = idx[3];
272 EXPECT_GE(i, 0);
273 EXPECT_LT(i, 4);
274 EXPECT_GE(j, 0);
275 EXPECT_LT(j, 2);
276 bool found = false;
277 for (int m = 0;m < 3;m++)
278 {
279 if (k == indices[m][0] && l == indices[m][1])
280 {
281 EXPECT_EQ(&v1[m](i, j), &v);
282 found = true;
283 visited[i][j][m]++;
284 }
285 }
286 EXPECT_TRUE(found);
287 });
288
289 for (len_type i = 0;i < 4;i++)
290 {
291 for (len_type j = 0;j < 2;j++)
292 {
293 for (len_type k = 0;k < 3;k++)
294 {
295 EXPECT_EQ(visited[i][j][k], 1);
296 }
297 }
298 }
299
300 visited = {};
301 v2.for_each_element(
302 [&](const double& v, const len_vector& idx)
303 {
304 EXPECT_EQ(idx.size(), 4u);
305 len_type i = idx[0];
306 len_type j = idx[1];
307 len_type k = idx[2];
308 len_type l = idx[3];
309 EXPECT_GE(i, 0);
310 EXPECT_LT(i, 4);
311 EXPECT_GE(j, 0);
312 EXPECT_LT(j, 2);
313 bool found = false;
314 for (int m = 0;m < 3;m++)
315 {
316 if (k == indices[m][0] && l == indices[m][1])
317 {
318 EXPECT_EQ(&v2[m](i, j), &v);
319 found = true;
320 visited[i][j][m]++;
321 }
322 }
323 EXPECT_TRUE(found);
324 });
325
326 for (len_type i = 0;i < 4;i++)
327 {
328 for (len_type j = 0;j < 2;j++)
329 {
330 for (len_type k = 0;k < 3;k++)
331 {
332 EXPECT_EQ(visited[i][j][k], 1);
333 }
334 }
335 }
336
337 visited = {};
338 v1.for_each_element<2,2>(
339 [&](double& v, len_type i, len_type j, len_type k, len_type l)
340 {
341 EXPECT_GE(i, 0);
342 EXPECT_LT(i, 4);
343 EXPECT_GE(j, 0);
344 EXPECT_LT(j, 2);
345 bool found = false;
346 for (int m = 0;m < 3;m++)
347 {
348 if (k == indices[m][0] && l == indices[m][1])
349 {
350 EXPECT_EQ(&v1[m](i, j), &v);
351 found = true;
352 visited[i][j][m]++;
353 }
354 }
355 EXPECT_TRUE(found);
356 });
357
358 for (len_type i = 0;i < 4;i++)
359 {
360 SCOPED_TRACE(i);
361 for (len_type j = 0;j < 2;j++)
362 {
363 SCOPED_TRACE(j);
364 for (len_type k = 0;k < 3;k++)
365 {
366 SCOPED_TRACE(k);
367 EXPECT_EQ(visited[i][j][k], 1);
368 }
369 }
370 }
371
372 visited = {};
373 v2.for_each_element<2,2>(
374 [&](const double& v, len_type i, len_type j, len_type k, len_type l)
375 {
376 EXPECT_GE(i, 0);
377 EXPECT_LT(i, 4);
378 EXPECT_GE(j, 0);
379 EXPECT_LT(j, 2);
380 bool found = false;
381 for (int m = 0;m < 3;m++)
382 {
383 if (k == indices[m][0] && l == indices[m][1])
384 {
385 EXPECT_EQ(&v2[m](i, j), &v);
386 found = true;
387 visited[i][j][m]++;
388 }
389 }
390 EXPECT_TRUE(found);
391 });
392
393 for (len_type i = 0;i < 4;i++)
394 {
395 for (len_type j = 0;j < 2;j++)
396 {
397 for (len_type k = 0;k < 3;k++)
398 {
399 EXPECT_EQ(visited[i][j][k], 1);
400 }
401 }
402 }
403 }
404
TEST(indexed_varray,swap)405 TEST(indexed_varray, swap)
406 {
407 indexed_varray<double> v1({4, 2, 5, 4}, {{0, 0}, {2, 1}, {4, 3}});
408 indexed_varray<double> v2({4, 5, 7}, {{0, 4}, {2, 2}, {4, 1}, {1, 1}});
409
410 auto data1 = v1.data();
411 auto data2 = v2.data();
412
413 v1.swap(v2);
414
415 EXPECT_EQ(4u, v2.dimension());
416 EXPECT_EQ(2u, v2.dense_dimension());
417 EXPECT_EQ(2u, v2.indexed_dimension());
418 EXPECT_EQ((len_vector{4, 2, 5, 4}), v2.lengths());
419 EXPECT_EQ((len_vector{4, 2}), v2.dense_lengths());
420 EXPECT_EQ((len_vector{5, 4}), v2.indexed_lengths());
421 EXPECT_EQ((stride_vector{2, 1}), v2.dense_strides());
422 EXPECT_EQ(3u, v2.num_indices());
423 EXPECT_EQ((matrix<len_type>{{0, 0}, {2, 1}, {4, 3}}), v2.indices());
424 EXPECT_EQ(3u, v1.dimension());
425 EXPECT_EQ(1u, v1.dense_dimension());
426 EXPECT_EQ(2u, v1.indexed_dimension());
427 EXPECT_EQ((len_vector{4, 5, 7}), v1.lengths());
428 EXPECT_EQ((len_vector{4}), v1.dense_lengths());
429 EXPECT_EQ((len_vector{5, 7}), v1.indexed_lengths());
430 EXPECT_EQ((stride_vector{1}), v1.dense_strides());
431 EXPECT_EQ(4u, v1.num_indices());
432 EXPECT_EQ((matrix<len_type>{{0, 4}, {2, 2}, {4, 1}, {1, 1}}), v1.indices());
433
434 swap(v2, v1);
435
436 EXPECT_EQ(4u, v1.dimension());
437 EXPECT_EQ(2u, v1.dense_dimension());
438 EXPECT_EQ(2u, v1.indexed_dimension());
439 EXPECT_EQ((len_vector{4, 2, 5, 4}), v1.lengths());
440 EXPECT_EQ((len_vector{4, 2}), v1.dense_lengths());
441 EXPECT_EQ((len_vector{5, 4}), v1.indexed_lengths());
442 EXPECT_EQ((stride_vector{2, 1}), v1.dense_strides());
443 EXPECT_EQ(3u, v1.num_indices());
444 EXPECT_EQ((matrix<len_type>{{0, 0}, {2, 1}, {4, 3}}), v1.indices());
445 EXPECT_EQ(3u, v2.dimension());
446 EXPECT_EQ(1u, v2.dense_dimension());
447 EXPECT_EQ(2u, v2.indexed_dimension());
448 EXPECT_EQ((len_vector{4, 5, 7}), v2.lengths());
449 EXPECT_EQ((len_vector{4}), v2.dense_lengths());
450 EXPECT_EQ((len_vector{5, 7}), v2.indexed_lengths());
451 EXPECT_EQ((stride_vector{1}), v2.dense_strides());
452 EXPECT_EQ(4u, v2.num_indices());
453 EXPECT_EQ((matrix<len_type>{{0, 4}, {2, 2}, {4, 1}, {1, 1}}), v2.indices());
454 }
455