1 #include "gtest/gtest.h"
2 #include "marray.hpp"
3 #include "rotate.hpp"
4 
5 using namespace std;
6 using namespace MArray;
7 
TEST(marray_view,constructor)8 TEST(marray_view, constructor)
9 {
10     double tmp;
11     double* data = &tmp;
12 
13     marray<double,3> v0({4, 2, 5});
14     marray<double,4> v01({3, 4, 2, 5});
15 
16     marray_view<double,2> v1;
17     EXPECT_EQ(nullptr, v1.data());
18     EXPECT_EQ((array<len_type,2>{0, 0}), v1.lengths());
19     EXPECT_EQ((array<stride_type,2>{0, 0}), v1.strides());
20 
21     marray_view<double,3> v2({4, 2, 5}, data);
22     EXPECT_EQ(data, v2.data());
23     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v2.lengths());
24     EXPECT_EQ((array<stride_type,3>{10, 5, 1}), v2.strides());
25 
26     marray_view<double,3> v3(array<char,3>{4, 2, 5}, data);
27     EXPECT_EQ(data, v3.data());
28     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v3.lengths());
29     EXPECT_EQ((array<stride_type,3>{10, 5, 1}), v3.strides());
30 
31     marray_view<double,3> v4({4, 2, 5}, data, COLUMN_MAJOR);
32     EXPECT_EQ(data, v4.data());
33     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v4.lengths());
34     EXPECT_EQ((array<stride_type,3>{1, 4, 8}), v4.strides());
35 
36     marray_view<double,3> v5(v2);
37     EXPECT_EQ(data, v5.data());
38     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v5.lengths());
39     EXPECT_EQ((array<stride_type,3>{10, 5, 1}), v5.strides());
40 
41     marray_view<double,3> v51(v0);
42     EXPECT_EQ(v0.data(), v51.data());
43     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v51.lengths());
44     EXPECT_EQ((array<stride_type,3>{10, 5, 1}), v51.strides());
45 
46     marray_view<double,3> v52(v01[0]);
47     EXPECT_EQ(v01.data(), v52.data());
48     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v52.lengths());
49     EXPECT_EQ((array<stride_type,3>{10, 5, 1}), v52.strides());
50 
51     marray_view<double,3> v6(marray_view<double,3>({4, 2, 5}, data));
52     EXPECT_EQ(data, v6.data());
53     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v6.lengths());
54     EXPECT_EQ((array<stride_type,3>{10, 5, 1}), v6.strides());
55 
56     marray_view<double,3> v7({4, 2, 5}, data, {3, 8, 24});
57     EXPECT_EQ(data, v7.data());
58     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v7.lengths());
59     EXPECT_EQ((array<stride_type,3>{3, 8, 24}), v7.strides());
60 
61     marray_view<double,3> v8(array<char,3>{4, 2, 5}, data, array<char,3>{3, 8, 24});
62     EXPECT_EQ(data, v8.data());
63     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v8.lengths());
64     EXPECT_EQ((array<stride_type,3>{3, 8, 24}), v8.strides());
65 
66     marray_view<const double,2> v9;
67     EXPECT_EQ(nullptr, v9.data());
68     EXPECT_EQ((array<len_type,2>{0, 0}), v9.lengths());
69     EXPECT_EQ((array<stride_type,2>{0, 0}), v9.strides());
70 
71     marray_view<const double,3> v10({4, 2, 5}, data);
72     EXPECT_EQ(data, v10.data());
73     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v10.lengths());
74     EXPECT_EQ((array<stride_type,3>{10, 5, 1}), v10.strides());
75 
76     marray_view<const double,3> v11(array<char,3>{4, 2, 5}, data);
77     EXPECT_EQ(data, v11.data());
78     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v11.lengths());
79     EXPECT_EQ((array<stride_type,3>{10, 5, 1}), v11.strides());
80 
81     marray_view<const double,3> v12({4, 2, 5}, data, COLUMN_MAJOR);
82     EXPECT_EQ(data, v12.data());
83     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v12.lengths());
84     EXPECT_EQ((array<stride_type,3>{1, 4, 8}), v12.strides());
85 
86     marray_view<const double,3> v13(v2);
87     EXPECT_EQ(data, v13.data());
88     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v13.lengths());
89     EXPECT_EQ((array<stride_type,3>{10, 5, 1}), v13.strides());
90 
91     marray_view<const double,3> v131(v0);
92     EXPECT_EQ(v0.data(), v131.data());
93     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v131.lengths());
94     EXPECT_EQ((array<stride_type,3>{10, 5, 1}), v131.strides());
95 
96     marray_view<const double,3> v132(v01[0]);
97     EXPECT_EQ(v01.data(), v132.data());
98     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v132.lengths());
99     EXPECT_EQ((array<stride_type,3>{10, 5, 1}), v132.strides());
100 
101     marray_view<const double,3> v14(v10);
102     EXPECT_EQ(data, v14.data());
103     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v14.lengths());
104     EXPECT_EQ((array<stride_type,3>{10, 5, 1}), v14.strides());
105 
106     marray_view<const double,3> v15(marray_view<double,3>({4, 2, 5}, data));
107     EXPECT_EQ(data, v15.data());
108     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v15.lengths());
109     EXPECT_EQ((array<stride_type,3>{10, 5, 1}), v15.strides());
110 
111     marray_view<const double,3> v16(marray_view<const double,3>({4, 2, 5}, data));
112     EXPECT_EQ(data, v16.data());
113     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v16.lengths());
114     EXPECT_EQ((array<stride_type,3>{10, 5, 1}), v16.strides());
115 
116     marray_view<const double,3> v17({4, 2, 5}, data, {3, 8, 24});
117     EXPECT_EQ(data, v17.data());
118     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v17.lengths());
119     EXPECT_EQ((array<stride_type,3>{3, 8, 24}), v17.strides());
120 
121     marray_view<const double,3> v18(array<char,3>{4, 2, 5}, data, array<char,3>{3, 8, 24});
122     EXPECT_EQ(data, v18.data());
123     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v18.lengths());
124     EXPECT_EQ((array<stride_type,3>{3, 8, 24}), v18.strides());
125 }
126 
TEST(marray_view,reset)127 TEST(marray_view, reset)
128 {
129     double tmp;
130     double* data = &tmp;
131 
132     marray_view<double,3> v1;
133     marray_view<const double,3> v2;
134     marray_view<double,3> v3({4, 2, 5}, data);
135     marray_view<const double,3> v4({4, 2, 5}, data);
136     marray<double,3> v0({4, 2, 5});
137     marray<double,4> v01({3, 4, 2, 5});
138 
139     v1.reset({4, 2, 5}, data);
140     EXPECT_EQ(data, v1.data());
141     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v1.lengths());
142     EXPECT_EQ((array<stride_type,3>{10, 5, 1}), v1.strides());
143 
144     v1.reset(array<char,3>{4, 2, 5}, data);
145     EXPECT_EQ(data, v1.data());
146     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v1.lengths());
147     EXPECT_EQ((array<stride_type,3>{10, 5, 1}), v1.strides());
148 
149     v1.reset({4, 2, 5}, data, COLUMN_MAJOR);
150     EXPECT_EQ(data, v1.data());
151     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v1.lengths());
152     EXPECT_EQ((array<stride_type,3>{1, 4, 8}), v1.strides());
153 
154     v1.reset(v3);
155     EXPECT_EQ(data, v1.data());
156     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v1.lengths());
157     EXPECT_EQ((array<stride_type,3>{10, 5, 1}), v1.strides());
158 
159     v1.reset(v0);
160     EXPECT_EQ(v0.data(), v1.data());
161     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v1.lengths());
162     EXPECT_EQ((array<stride_type,3>{10, 5, 1}), v1.strides());
163 
164     v1.reset(v01[0]);
165     EXPECT_EQ(v01.data(), v1.data());
166     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v1.lengths());
167     EXPECT_EQ((array<stride_type,3>{10, 5, 1}), v1.strides());
168 
169     v1.reset(marray_view<double,3>({4, 2, 5}, data));
170     EXPECT_EQ(data, v1.data());
171     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v1.lengths());
172     EXPECT_EQ((array<stride_type,3>{10, 5, 1}), v1.strides());
173 
174     v1.reset({4, 2, 5}, data, {3, 8, 24});
175     EXPECT_EQ(data, v1.data());
176     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v1.lengths());
177     EXPECT_EQ((array<stride_type,3>{3, 8, 24}), v1.strides());
178 
179     v1.reset(array<char,3>{4, 2, 5}, data, array<char,3>{3, 8, 24});
180     EXPECT_EQ(data, v1.data());
181     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v1.lengths());
182     EXPECT_EQ((array<stride_type,3>{3, 8, 24}), v1.strides());
183 
184     v1.reset();
185     EXPECT_EQ(nullptr, v1.data());
186     EXPECT_EQ((array<len_type,3>{0, 0, 0}), v1.lengths());
187     EXPECT_EQ((array<stride_type,3>{0, 0, 0}), v1.strides());
188 
189     v2.reset({4, 2, 5}, data);
190     EXPECT_EQ(data, v2.data());
191     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v2.lengths());
192     EXPECT_EQ((array<stride_type,3>{10, 5, 1}), v2.strides());
193 
194     v2.reset(array<char,3>{4, 2, 5}, data);
195     EXPECT_EQ(data, v2.data());
196     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v2.lengths());
197     EXPECT_EQ((array<stride_type,3>{10, 5, 1}), v2.strides());
198 
199     v2.reset({4, 2, 5}, data, COLUMN_MAJOR);
200     EXPECT_EQ(data, v2.data());
201     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v2.lengths());
202     EXPECT_EQ((array<stride_type,3>{1, 4, 8}), v2.strides());
203 
204     v2.reset(v3);
205     EXPECT_EQ(data, v2.data());
206     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v2.lengths());
207     EXPECT_EQ((array<stride_type,3>{10, 5, 1}), v2.strides());
208 
209     v2.reset(v0);
210     EXPECT_EQ(v0.data(), v2.data());
211     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v2.lengths());
212     EXPECT_EQ((array<stride_type,3>{10, 5, 1}), v2.strides());
213 
214     v2.reset(v01[0]);
215     EXPECT_EQ(v01.data(), v2.data());
216     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v2.lengths());
217     EXPECT_EQ((array<stride_type,3>{10, 5, 1}), v2.strides());
218 
219     v2.reset(v4);
220     EXPECT_EQ(data, v2.data());
221     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v2.lengths());
222     EXPECT_EQ((array<stride_type,3>{10, 5, 1}), v2.strides());
223 
224     v2.reset(marray_view<double,3>({4, 2, 5}, data));
225     EXPECT_EQ(data, v2.data());
226     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v2.lengths());
227     EXPECT_EQ((array<stride_type,3>{10, 5, 1}), v2.strides());
228 
229     v2.reset(marray_view<const double,3>({4, 2, 5}, data));
230     EXPECT_EQ(data, v2.data());
231     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v2.lengths());
232     EXPECT_EQ((array<stride_type,3>{10, 5, 1}), v2.strides());
233 
234     v2.reset({4, 2, 5}, data, {3, 8, 24});
235     EXPECT_EQ(data, v2.data());
236     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v2.lengths());
237     EXPECT_EQ((array<stride_type,3>{3, 8, 24}), v2.strides());
238 
239     v2.reset(array<char,3>{4, 2, 5}, data, array<char,3>{3, 8, 24});
240     EXPECT_EQ(data, v2.data());
241     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v2.lengths());
242     EXPECT_EQ((array<stride_type,3>{3, 8, 24}), v2.strides());
243 
244     v2.reset();
245     EXPECT_EQ(nullptr, v1.data());
246     EXPECT_EQ((array<len_type,3>{0, 0, 0}), v2.lengths());
247     EXPECT_EQ((array<stride_type,3>{0, 0, 0}), v2.strides());
248 }
249 
TEST(marray_view,initialize)250 TEST(marray_view, initialize)
251 {
252     std::array<double,18> data = {};
253 
254     marray_view<double,3> v1({3, 2, 3}, data.data(), ROW_MAJOR);
255     marray_view<double,3> v2({3, 2, 3}, data.data(), COLUMN_MAJOR);
256 
257     v1 = {{{ 0, 1, 2},
258            { 3, 4, 5}},
259           {{ 6, 7, 8},
260            { 9,10,11}},
261           {{12,13,14},
262            {15,16,17}}};
263 
264     EXPECT_EQ((std::array<double,18>{ 0, 1, 2, 3, 4, 5,
265                                         6, 7, 8, 9,10,11,
266                                        12,13,14,15,16,17}), data);
267 
268     v2 = {{{ 0, 1, 2},
269            { 3, 4, 5}},
270           {{ 6, 7, 8},
271            { 9,10,11}},
272           {{12,13,14},
273            {15,16,17}}};
274 
275     EXPECT_EQ((std::array<double,18>{ 0, 6,12, 3, 9,15,
276                                       1, 7,13, 4,10,16,
277                                       2, 8,14, 5,11,17}), data);
278 }
279 
TEST(marray_view,shift)280 TEST(marray_view, shift)
281 {
282     double tmp;
283     double* data = &tmp;
284 
285     marray_view<double,3> v1({4, 2, 5}, data);
286 
287     auto v2 = v1.shifted(0, 2);
288     EXPECT_EQ(v1.lengths(), v2.lengths());
289     EXPECT_EQ(v1.strides(), v2.strides());
290     EXPECT_EQ(v1.data() + 2*v1.stride(0), v2.data());
291 
292     auto v3 = v1.shifted(1, -3);
293     EXPECT_EQ(v1.lengths(), v3.lengths());
294     EXPECT_EQ(v1.strides(), v3.strides());
295     EXPECT_EQ(v1.data() - 3*v1.stride(1), v3.data());
296 
297     auto v4 = v1.shifted_down(2);
298     EXPECT_EQ(v1.lengths(), v4.lengths());
299     EXPECT_EQ(v1.strides(), v4.strides());
300     EXPECT_EQ(v1.data() + v1.length(2)*v1.stride(2), v4.data());
301 
302     auto v5 = v1.shifted_up(0);
303     EXPECT_EQ(v1.lengths(), v5.lengths());
304     EXPECT_EQ(v1.strides(), v5.strides());
305     EXPECT_EQ(v1.data() - v1.length(0)*v1.stride(0), v5.data());
306 
307     auto ref = v1.data();
308     v1.shift(0, 2);
309     EXPECT_EQ(ref + 2*v1.stride(0), v1.data());
310 
311     ref = v1.data();
312     v1.shift(1, -3);
313     EXPECT_EQ(ref - 3*v1.stride(1), v1.data());
314 
315     ref = v1.data();
316     v1.shift_down(2);
317     EXPECT_EQ(ref + v1.length(2)*v1.stride(2), v1.data());
318 
319     ref = v1.data();
320     v1.shift_up(0);
321     EXPECT_EQ(ref - v1.length(0)*v1.stride(0), v1.data());
322 }
323 
TEST(marray_view,permute)324 TEST(marray_view, permute)
325 {
326     double tmp;
327     double* data = &tmp;
328 
329     marray_view<double,3> v1({4, 2, 5}, data);
330 
331     auto v2 = v1.permuted({1, 0, 2});
332     EXPECT_EQ((array<len_type,3>{2, 4, 5}), v2.lengths());
333     EXPECT_EQ((array<stride_type,3>{5, 10, 1}), v2.strides());
334     EXPECT_EQ(v1.data(), v2.data());
335 
336     auto v3 = v1.permuted(array<char,3>{2, 0, 1});
337     EXPECT_EQ((array<len_type,3>{5, 4, 2}), v3.lengths());
338     EXPECT_EQ((array<stride_type,3>{1, 10, 5}), v3.strides());
339     EXPECT_EQ(v1.data(), v3.data());
340 
341     v1.permute({1, 0, 2});
342     EXPECT_EQ((array<len_type,3>{2, 4, 5}), v1.lengths());
343     EXPECT_EQ((array<stride_type,3>{5, 10, 1}), v1.strides());
344     EXPECT_EQ(data, v1.data());
345 
346     v1.permute(array<char,3>{2, 0, 1});
347     EXPECT_EQ((array<len_type,3>{5, 2, 4}), v1.lengths());
348     EXPECT_EQ((array<stride_type,3>{1, 5, 10}), v1.strides());
349     EXPECT_EQ(data, v1.data());
350 }
351 
TEST(marray_view,transpose)352 TEST(marray_view, transpose)
353 {
354     double tmp;
355     double* data = &tmp;
356 
357     marray_view<double,2> v1({4, 8}, data);
358 
359     auto v2 = v1.transposed();
360     EXPECT_EQ((array<len_type,2>{8, 4}), v2.lengths());
361     EXPECT_EQ((array<stride_type,2>{1, 8}), v2.strides());
362     EXPECT_EQ(v1.data(), v2.data());
363 
364     auto v3 = v1.T();
365     EXPECT_EQ((array<len_type,2>{8, 4}), v3.lengths());
366     EXPECT_EQ((array<stride_type,2>{1, 8}), v3.strides());
367     EXPECT_EQ(v1.data(), v3.data());
368 
369     v1.transpose();
370     EXPECT_EQ((array<len_type,2>{8, 4}), v1.lengths());
371     EXPECT_EQ((array<stride_type,2>{1, 8}), v1.strides());
372     EXPECT_EQ(data, v1.data());
373 }
374 
TEST(marray_view,lowered)375 TEST(marray_view, lowered)
376 {
377     double tmp;
378     double* data = &tmp;
379 
380     marray_view<double,3> v1({4, 2, 5}, data);
381 
382     auto v2 = v1.lowered<3>({1, 2});
383     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v2.lengths());
384     EXPECT_EQ((array<stride_type,3>{10, 5, 1}), v2.strides());
385     EXPECT_EQ(v1.data(), v2.data());
386 
387     auto v3 = v1.lowered<2>(array<char,1>{1});
388     EXPECT_EQ((array<len_type,2>{4, 10}), v3.lengths());
389     EXPECT_EQ((array<stride_type,2>{10, 1}), v3.strides());
390     EXPECT_EQ(v1.data(), v3.data());
391 
392     auto v4 = v1.lowered<1>({});
393     EXPECT_EQ((array<len_type,1>{40}), v4.lengths());
394     EXPECT_EQ((array<stride_type,1>{1}), v4.strides());
395     EXPECT_EQ(v1.data(), v4.data());
396 }
397 
TEST(marray_view,rotate)398 TEST(marray_view, rotate)
399 {
400     array<double,12> data = { 0, 1, 2,
401                               3, 4, 5,
402                               6, 7, 8,
403                               9,10,11};
404 
405     marray_view<double,2> v1({4, 3}, data.data());
406 
407     rotate(v1, 1, 1);
408     EXPECT_EQ((array<double,12>{ 1, 2, 0,
409                                  4, 5, 3,
410                                  7, 8, 6,
411                                 10,11, 9}), data);
412 
413     rotate(v1, 0, -1);
414     EXPECT_EQ((array<double,12>{10,11, 9,
415                                  1, 2, 0,
416                                  4, 5, 3,
417                                  7, 8, 6}), data);
418 
419     rotate(v1, {4,3});
420     EXPECT_EQ((array<double,12>{10,11, 9,
421                                  1, 2, 0,
422                                  4, 5, 3,
423                                  7, 8, 6}), data);
424 
425     rotate(v1, array<char,2>{1,1});
426     EXPECT_EQ((array<double,12>{ 2, 0, 1,
427                                  5, 3, 4,
428                                  8, 6, 7,
429                                 11, 9,10}), data);
430 }
431 
TEST(marray_view,front_back)432 TEST(marray_view, front_back)
433 {
434     double tmp;
435     double* data = &tmp;
436 
437     marray_view<double,1> v1({8}, data);
438 
439     EXPECT_EQ(data, &v1.cfront());
440     EXPECT_EQ(data, &v1.front());
441     EXPECT_EQ(data+7, &v1.cback());
442     EXPECT_EQ(data+7, &v1.back());
443 
444     marray_view<double,3> v2({4, 2, 5}, data);
445 
446     auto v3 = v2.cfront(0);
447     EXPECT_EQ((array<len_type,2>{2, 5}), v3.lengths());
448     EXPECT_EQ((array<stride_type,2>{5, 1}), v3.strides());
449     EXPECT_EQ(data, v3.data());
450 
451     auto v4 = v2.front(1);
452     EXPECT_EQ((array<len_type,2>{4, 5}), v4.lengths());
453     EXPECT_EQ((array<stride_type,2>{10, 1}), v4.strides());
454     EXPECT_EQ(data, v4.data());
455 
456     auto v5 = v2.cback(0);
457     EXPECT_EQ((array<len_type,2>{2, 5}), v5.lengths());
458     EXPECT_EQ((array<stride_type,2>{5, 1}), v5.strides());
459     EXPECT_EQ(data + 30, v5.data());
460 
461     auto v6 = v2.back(1);
462     EXPECT_EQ((array<len_type,2>{4, 5}), v6.lengths());
463     EXPECT_EQ((array<stride_type,2>{10, 1}), v6.strides());
464     EXPECT_EQ(data + 5, v6.data());
465 }
466 
TEST(marray_view,access)467 TEST(marray_view, access)
468 {
469     array<double,12> data = { 0, 1, 2,
470                               3, 4, 5,
471                               6, 7, 8,
472                               9,10,11};
473 
474     marray_view<double,2> v1({4, 3}, data.data());
475 
476     EXPECT_EQ( 0, v1(0, 0));
477     EXPECT_EQ( 5, v1(1, 2));
478     EXPECT_EQ(10, v1(3, 1));
479 
480     EXPECT_EQ( 0, v1[0][0]);
481     EXPECT_EQ( 5, v1[1][2]);
482     EXPECT_EQ(10, v1[3][1]);
483 
484     auto v2 = view(v1(slice::all, range(2)));
485     EXPECT_EQ((array<len_type,2>{4, 2}), v2.lengths());
486     EXPECT_EQ((array<stride_type,2>{3, 1}), v2.strides());
487     EXPECT_EQ(v1.data(), v2.data());
488 
489     auto v3 = view(v1(range(0, 4, 2), 1));
490     EXPECT_EQ((array<len_type,1>{2}), v3.lengths());
491     EXPECT_EQ((array<stride_type,1>{6}), v3.strides());
492     EXPECT_EQ(v1.data() + 1, v3.data());
493 
494     auto v4 = view(v1[slice::all][range(2)]);
495     EXPECT_EQ((array<len_type,2>{4, 2}), v4.lengths());
496     EXPECT_EQ((array<stride_type,2>{3, 1}), v4.strides());
497     EXPECT_EQ(v1.data(), v4.data());
498 
499     auto v5 = view(v1[range(1,3)]);
500     EXPECT_EQ((array<len_type,2>{2,3}), v5.lengths());
501     EXPECT_EQ((array<stride_type,2>{3,1}), v5.strides());
502     EXPECT_EQ(v1.data() + 3, v5.data());
503 
504     auto v6 = view(v1[2]);
505     EXPECT_EQ((array<len_type,1>{3}), v6.lengths());
506     EXPECT_EQ((array<stride_type,1>{1}), v6.strides());
507     EXPECT_EQ(v1.data() + 6, v6.data());
508 }
509 
TEST(marray_view,iteration)510 TEST(marray_view, iteration)
511 {
512     array<array<int,3>,4> visited;
513     array<array<double,3>,4> data = {{{ 0, 1, 2},
514                                       { 3, 4, 5},
515                                       { 6, 7, 8},
516                                       { 9,10,11}}};
517 
518     marray_view<double,2> v1({4, 3}, &data[0][0]);
519     marray_view<const double,2> v2({4, 3}, &data[0][0]);
520 
521     visited = {};
522     v1.for_each_element(
523     [&](double& v, len_type i, len_type j)
524     {
525         EXPECT_GE(i, 0);
526         EXPECT_LT(i, 4);
527         EXPECT_GE(j, 0);
528         EXPECT_LT(j, 3);
529         EXPECT_EQ(v, data[i][j]);
530         visited[i][j]++;
531     });
532 
533     for (len_type i = 0;i < 4;i++)
534     {
535         for (len_type j = 0;j < 3;j++)
536         {
537             EXPECT_EQ(visited[i][j], 1);
538         }
539     }
540 
541     visited = {};
542     v2.for_each_element(
543     [&](const double& v, len_type i, len_type j)
544     {
545         EXPECT_GE(i, 0);
546         EXPECT_LT(i, 4);
547         EXPECT_GE(j, 0);
548         EXPECT_LT(j, 3);
549         EXPECT_EQ(v, data[i][j]);
550         visited[i][j]++;
551     });
552 
553     for (len_type i = 0;i < 4;i++)
554     {
555         for (len_type j = 0;j < 3;j++)
556         {
557             EXPECT_EQ(visited[i][j], 1);
558         }
559     }
560 }
561 
TEST(marray_view,length_stride)562 TEST(marray_view, length_stride)
563 {
564     double tmp;
565     double* data = &tmp;
566 
567     marray_view<double,3> v1({4, 2, 5}, data);
568 
569     EXPECT_EQ(4, v1.length(0));
570     EXPECT_EQ(4, v1.length(0, 2));
571     EXPECT_EQ(2, v1.length(0));
572 
573     EXPECT_EQ(5, v1.length(2));
574     EXPECT_EQ(5, v1.length(2, 7));
575     EXPECT_EQ(7, v1.length(2));
576 
577     EXPECT_EQ(10, v1.stride(0));
578     EXPECT_EQ(10, v1.stride(0, 12));
579     EXPECT_EQ(12, v1.stride(0));
580 
581     EXPECT_EQ(1, v1.stride(2));
582     EXPECT_EQ(1, v1.stride(2, 2));
583     EXPECT_EQ(2, v1.stride(2));
584 
585     EXPECT_EQ((array<len_type,3>{2, 2, 7}), v1.lengths());
586     EXPECT_EQ((array<stride_type,3>{12, 5, 2}), v1.strides());
587 }
588 
TEST(marray_view,swap)589 TEST(marray_view, swap)
590 {
591     double tmp1, tmp2;
592     double* data1 = &tmp1;
593     double* data2 = &tmp2;
594 
595     marray_view<double,3> v1({4, 2, 5}, data1);
596     marray_view<double,3> v2({3, 8, 3}, data2);
597 
598     v1.swap(v2);
599 
600     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v2.lengths());
601     EXPECT_EQ((array<stride_type,3>{10, 5, 1}), v2.strides());
602     EXPECT_EQ(data1, v2.data());
603     EXPECT_EQ((array<len_type,3>{3, 8, 3}), v1.lengths());
604     EXPECT_EQ((array<stride_type,3>{24, 3, 1}), v1.strides());
605     EXPECT_EQ(data2, v1.data());
606 
607     swap(v2, v1);
608 
609     EXPECT_EQ((array<len_type,3>{4, 2, 5}), v1.lengths());
610     EXPECT_EQ((array<stride_type,3>{10, 5, 1}), v1.strides());
611     EXPECT_EQ(data1, v1.data());
612     EXPECT_EQ((array<len_type,3>{3, 8, 3}), v2.lengths());
613     EXPECT_EQ((array<stride_type,3>{24, 3, 1}), v2.strides());
614     EXPECT_EQ(data2, v2.data());
615 }
616 
TEST(marray_view,print)617 TEST(marray_view, print)
618 {
619     double data[2][2][3] =
620     {
621      {
622       {0, 1, 2},
623       {3, 4, 5}
624      },
625      {
626       {6, 7, 8},
627       {9, 10, 11}
628      }
629     };
630 
631     marray_view<double,3> v1({2,2,3}, (double*)data, ROW_MAJOR);
632 
633     std::string expected =
634 R"XXX({
635  {
636   {0, 1, 2},
637   {3, 4, 5}
638  },
639  {
640   {6, 7, 8},
641   {9, 10, 11}
642  }
643 })XXX";
644 
645     std::ostringstream oss;
646     oss << v1;
647 
648     EXPECT_EQ(oss.str(), expected);
649 }
650