1 #include "gtest/gtest.h"
2 #include "indexed_dpd_varray.hpp"
3
4 using namespace std;
5 using namespace MArray;
6
7 static dpd_layout layouts[6] =
8 {
9 PREFIX_ROW_MAJOR,
10 PREFIX_COLUMN_MAJOR,
11 BLOCKED_ROW_MAJOR,
12 BLOCKED_COLUMN_MAJOR,
13 BALANCED_ROW_MAJOR,
14 BALANCED_COLUMN_MAJOR,
15 };
16
17 static dim_vector perms[6] =
18 {{3,2,1,0}, {0,1,2,3}, {3,2,1,0}, {0,1,2,3}, {3,2,1,0}, {0,1,2,3}};
19
20 static irrep_vector irreps[8] =
21 {{1,0,0,0}, {0,1,0,0}, {0,0,1,0}, {1,1,1,0},
22 {0,0,0,1}, {1,1,0,1}, {1,0,1,1}, {0,1,1,1}};
23 static len_vector lengths[8] =
24 {{1,2,1,3}, {3,2,1,3}, {3,2,2,3}, {1,2,2,3},
25 {3,2,1,4}, {1,2,1,4}, {1,2,2,4}, {3,2,2,4}};
26
27 static stride_vector strides[6][8] =
28 {
29 {{42,11, 3, 1}, {42,11, 3, 1}, {42,10, 3, 1}, {42,10, 3, 1},
30 {42,10, 4, 1}, {42,10, 4, 1}, {42,11, 4, 1}, {42,11, 4, 1}},
31 {{ 1, 1, 8,24}, { 1, 3, 8,24}, { 1, 3, 8,24}, { 1, 1, 8,24},
32 { 1, 3, 8,24}, { 1, 1, 8,24}, { 1, 1, 8,24}, { 1, 3, 8,24}},
33 {{ 6, 3, 3, 1}, { 6, 3, 3, 1}, {12, 6, 3, 1}, {12, 6, 3, 1},
34 { 8, 4, 4, 1}, { 8, 4, 4, 1}, {16, 8, 4, 1}, {16, 8, 4, 1}},
35 {{ 1, 1, 2, 2}, { 1, 3, 6, 6}, { 1, 3, 6,12}, { 1, 1, 2, 4},
36 { 1, 3, 6, 6}, { 1, 1, 2, 2}, { 1, 1, 2, 4}, { 1, 3, 6,12}},
37 {{22,11, 3, 1}, {22,11, 3, 1}, {20,10, 3, 1}, {20,10, 3, 1},
38 {20,10, 4, 1}, {20,10, 4, 1}, {22,11, 4, 1}, {22,11, 4, 1}},
39 {{ 1, 1, 8, 8}, { 1, 3, 8, 8}, { 1, 3, 8,16}, { 1, 1, 8,16},
40 { 1, 3, 8, 8}, { 1, 1, 8, 8}, { 1, 1, 8,16}, { 1, 3, 8,16}}
41 };
42
43 static stride_type offsets[6][8] =
44 {
45 {126, 20, 4,152, 0,148,129, 23},
46 { 0, 2, 8, 14, 72, 78, 80, 82},
47 {162,144, 96,132, 0, 24, 80, 32},
48 { 0, 42,108, 22,144, 34, 6, 60},
49 { 80+66, 80 , 0+4, 0+60+4,
50 0 , 0+60, 80+66+3, 80 +3},
51 { 0 , 0 +2, 88 , 88 +6,
52 88+48, 88+48+6, 0+24, 0+24+2}
53 };
54
55 #define CHECK_INDEXED_DPD_VARRAY_RESET(v) \
56 EXPECT_EQ(0u, v.dimension()); \
57 EXPECT_EQ(0u, v.dense_dimension()); \
58 EXPECT_EQ(0u, v.indexed_dimension()); \
59 EXPECT_EQ(1u, v.num_indices()); \
60 EXPECT_EQ((dim_vector{}), v.permutation()); \
61 EXPECT_EQ((matrix<len_type>{}), v.lengths()); \
62 EXPECT_EQ(0u, v.data().size());
63
64 #define CHECK_INDEXED_DPD_VARRAY(v,j,value,...) \
65 SCOPED_TRACE(j); \
66 EXPECT_EQ(6u, v.dimension()); \
67 EXPECT_EQ(4u, v.dense_dimension()); \
68 EXPECT_EQ(2u, v.indexed_dimension()); \
69 EXPECT_EQ((matrix<len_type>{{3, 1}, {2, 2}, {1, 2}, {3, 4}, {2, 2}, {4, 5}}), v.lengths()); \
70 EXPECT_EQ((matrix<len_type>{{3, 1}, {2, 2}, {1, 2}, {3, 4}}), v.dense_lengths()); \
71 EXPECT_EQ((len_vector{2, 5}), v.indexed_lengths()); \
72 EXPECT_EQ(3u, v.num_indices()); \
73 EXPECT_EQ((irrep_vector{1, 1}), v.indexed_irreps()); \
74 EXPECT_EQ((matrix<len_type>{{0, 0}, {1, 3}, {0, 3}}), v.indices()); \
75 EXPECT_EQ(value, v.data(0)[0]); \
76 EXPECT_EQ(1u, v.irrep()); \
77 EXPECT_EQ(2u, v.num_irreps()); \
78 EXPECT_EQ(perms[j], v.permutation()); \
79 \
80 for (unsigned m = 0;m < 3u;m++) \
81 { \
82 SCOPED_TRACE(m); \
83 { \
84 auto vs = v[m](1,0,0,0); \
85 EXPECT_EQ(v.data(m) + offsets[j][0], vs.data()); \
86 for (unsigned k = 0;k < 4;k++) \
87 { \
88 SCOPED_TRACE(k); \
89 EXPECT_EQ(lengths[0][k], vs.length(k)); \
90 EXPECT_EQ(strides[j][0][k], vs.stride(k)); \
91 } \
92 } \
93 \
94 { \
95 auto vs = v[m]({0,1,0,0}); \
96 EXPECT_EQ(v.data(m) + offsets[j][1], vs.data()); \
97 EXPECT_EQ(lengths[1], vs.lengths()); \
98 EXPECT_EQ(strides[j][1], vs.strides()); \
99 } \
100 \
101 for (unsigned i = 2;i < 8;i++) \
102 { \
103 SCOPED_TRACE(i); \
104 auto vs = v[m](irreps[i]); \
105 EXPECT_EQ(v.data(m) + offsets[j][i], vs.data()); \
106 EXPECT_EQ(lengths[i], vs.lengths()); \
107 EXPECT_EQ(strides[j][i], vs.strides()); \
108 } \
109 }
110
TEST(indexed_dpd_varray,constructor)111 TEST(indexed_dpd_varray, constructor)
112 {
113 indexed_dpd_varray<double> v1;
114 CHECK_INDEXED_DPD_VARRAY_RESET(v1)
115
116 for (int j = 0;j < 6;j++)
117 {
118 indexed_dpd_varray<double> v2(1, 2, {{3, 1}, {2, 2}, {1, 2}, {3, 4}, {2, 2}, {4, 5}},
119 {1, 1}, {{0, 0}, {1, 3}, {0, 3}}, layouts[j]);
120 CHECK_INDEXED_DPD_VARRAY(v2, j, 0.0)
121
122 indexed_dpd_varray<double> v21(1, 2, {{3, 1}, {2, 2}, {1, 2}, {3, 4}, {2, 2}, {4, 5}},
123 {1, 1}, {{0, 0}, {1, 3}, {0, 3}}, 1.0, layouts[j]);
124 CHECK_INDEXED_DPD_VARRAY(v21, j, 1.0)
125
126 indexed_dpd_varray<double> v5(v21.view(), layouts[j]);
127 CHECK_INDEXED_DPD_VARRAY(v5, j, 1.0)
128
129 indexed_dpd_varray<double> v52(v21.cview(), layouts[j]);
130 CHECK_INDEXED_DPD_VARRAY(v52, j, 1.0)
131
132 indexed_dpd_varray<double> v51(v21);
133 CHECK_INDEXED_DPD_VARRAY(v51, j, 1.0)
134
135 indexed_dpd_varray<double> v53(v21, layouts[j]);
136 CHECK_INDEXED_DPD_VARRAY(v53, j, 1.0)
137 }
138 }
139
TEST(indexed_dpd_varray,reset)140 TEST(indexed_dpd_varray, reset)
141 {
142 indexed_dpd_varray<double> v1;
143 CHECK_INDEXED_DPD_VARRAY_RESET(v1)
144
145 for (int j = 0;j < 6;j++)
146 {
147 indexed_dpd_varray<double> v2(1, 2, {{3, 1}, {2, 2}, {1, 2}, {3, 4}, {2, 2}, {4, 5}},
148 {1, 1}, {{0, 0}, {1, 3}, {0, 3}}, 1.0, layouts[j]);
149
150 v1.reset(1, 2, {{3, 1}, {2, 2}, {1, 2}, {3, 4}, {2, 2}, {4, 5}},
151 {1, 1}, {{0, 0}, {1, 3}, {0, 3}}, layouts[j]);
152 CHECK_INDEXED_DPD_VARRAY(v1, j, 0.0)
153
154 v1.reset(1, 2, {{3, 1}, {2, 2}, {1, 2}, {3, 4}, {2, 2}, {4, 5}},
155 {1, 1}, {{0, 0}, {1, 3}, {0, 3}}, 1.0, layouts[j]);
156 CHECK_INDEXED_DPD_VARRAY(v1, j, 1.0)
157
158 v1.reset(v2.view(), layouts[j]);
159 CHECK_INDEXED_DPD_VARRAY(v1, j, 1.0)
160
161 v1.reset(v2.cview(), layouts[j]);
162 CHECK_INDEXED_DPD_VARRAY(v1, j, 1.0)
163
164 v1.reset(v2);
165 CHECK_INDEXED_DPD_VARRAY(v1, j, 1.0)
166
167 v1.reset(v2, layouts[j]);
168 CHECK_INDEXED_DPD_VARRAY(v1, j, 1.0)
169 }
170
171 v1.reset();
172 CHECK_INDEXED_DPD_VARRAY_RESET(v1)
173 }
174
TEST(indexed_dpd_varray,view)175 TEST(indexed_dpd_varray, view)
176 {
177 indexed_dpd_varray<double> v1(1, 2, {{3, 1}, {2, 2}, {1, 2}, {3, 4}, {2, 2}, {4, 5}},
178 {1, 1}, {{0, 0}, {1, 3}, {0, 3}}, 1.0, layouts[0]);
179
180 auto v2 = v1.cview();
181 CHECK_INDEXED_DPD_VARRAY(v2, 0, 1.0)
182
183 auto v3 = v1.view();
184 CHECK_INDEXED_DPD_VARRAY(v3, 0, 1.0)
185
186 auto v4 = const_cast<const indexed_dpd_varray<double>&>(v1).view();
187 CHECK_INDEXED_DPD_VARRAY(v4, 0, 1.0)
188 }
189
TEST(indexed_dpd_varray,access)190 TEST(indexed_dpd_varray, access)
191 {
192 indexed_dpd_varray<double> v1(1, 2, {{3, 1}, {2, 2}, {1, 2}, {3, 4}, {2, 2}, {4, 5}},
193 {1, 1}, {{0, 0}, {1, 3}, {0, 3}}, 1.0, layouts[0]);
194
195 auto v2 = v1[0];
196 EXPECT_EQ(v1.data(0), v2.data());
197 EXPECT_EQ(1u, v2.irrep());
198 EXPECT_EQ(2u, v2.num_irreps());
199 EXPECT_EQ(perms[0], v2.permutation());
200 EXPECT_EQ((matrix<len_type>{{3, 1}, {2, 2}, {1, 2}, {3, 4}}), v2.lengths());
201
202 auto v3 = const_cast<const indexed_dpd_varray<double>&>(v1)[2];
203 EXPECT_EQ(v1.data(2), v3.data());
204 EXPECT_EQ(1u, v3.irrep());
205 EXPECT_EQ(2u, v3.num_irreps());
206 EXPECT_EQ(perms[0], v3.permutation());
207 EXPECT_EQ((matrix<len_type>{{3, 1}, {2, 2}, {1, 2}, {3, 4}}), v3.lengths());
208 }
209
TEST(indexed_dpd_varray,index_iteration)210 TEST(indexed_dpd_varray, index_iteration)
211 {
212 int indices[3][2] = {{0, 0}, {1, 3}, {0, 3}};
213 array<int,3> visited;
214
215 indexed_dpd_varray<double> v1(1, 2, {{3, 1}, {2, 2}, {1, 2}, {3, 4}, {2, 2}, {4, 5}},
216 {1, 1}, {{0, 0}, {1, 3}, {0, 3}}, 1.0, layouts[0]);
217 const indexed_dpd_varray<double> v2(v1);
218
219 visited = {};
220 v1.for_each_index(
221 [&](const dpd_varray_view<double>& v, const index_vector& idx)
222 {
223 EXPECT_EQ(idx.size(), 2u);
224 len_type i = idx[0];
225 len_type j = idx[1];
226 bool found = false;
227 for (int m = 0;m < 3;m++)
228 {
229 if (i == indices[m][0] && j == indices[m][1])
230 {
231 EXPECT_EQ(v1.data(m), v.data());
232 found = true;
233 visited[m]++;
234 }
235 }
236 EXPECT_TRUE(found);
237 EXPECT_EQ(1u, v.irrep());
238 EXPECT_EQ(2u, v.num_irreps());
239 EXPECT_EQ(perms[0], v.permutation());
240 EXPECT_EQ((matrix<len_type>{{3, 1}, {2, 2}, {1, 2}, {3, 4}}), v.lengths());
241 });
242
243 for (len_type i = 0;i < 3;i++)
244 {
245 EXPECT_EQ(visited[i], 1);
246 }
247
248 visited = {};
249 v2.for_each_index(
250 [&](const dpd_varray_view<const double>& v, const index_vector& idx)
251 {
252 EXPECT_EQ(idx.size(), 2u);
253 len_type i = idx[0];
254 len_type j = idx[1];
255 bool found = false;
256 for (int m = 0;m < 3;m++)
257 {
258 if (i == indices[m][0] && j == indices[m][1])
259 {
260 EXPECT_EQ(v2.data(m), v.data());
261 found = true;
262 visited[m]++;
263 }
264 }
265 EXPECT_TRUE(found);
266 EXPECT_EQ(1u, v.irrep());
267 EXPECT_EQ(2u, v.num_irreps());
268 EXPECT_EQ(perms[0], v.permutation());
269 EXPECT_EQ((matrix<len_type>{{3, 1}, {2, 2}, {1, 2}, {3, 4}}), v.lengths());
270 });
271
272 for (len_type i = 0;i < 3;i++)
273 {
274 EXPECT_EQ(visited[i], 1);
275 }
276
277 visited = {};
278 v1.for_each_index<4,2>(
279 [&](const dpd_marray_view<double,4>& v, len_type i, len_type j)
280 {
281 bool found = false;
282 for (int m = 0;m < 3;m++)
283 {
284 if (i == indices[m][0] && j == indices[m][1])
285 {
286 EXPECT_EQ(v1.data(m), v.data());
287 found = true;
288 visited[m]++;
289 }
290 }
291 EXPECT_TRUE(found);
292 EXPECT_EQ(1u, v.irrep());
293 EXPECT_EQ(2u, v.num_irreps());
294 EXPECT_EQ((*reinterpret_cast<std::array<unsigned,4>*>(perms[0].data())), v.permutation());
295 EXPECT_EQ((std::array<std::array<len_type,8>,4>{{{3, 1}, {2, 2}, {1, 2}, {3, 4}}}), v.lengths());
296 });
297
298 for (len_type i = 0;i < 3;i++)
299 {
300 EXPECT_EQ(visited[i], 1);
301 }
302
303 visited = {};
304 v2.for_each_index<4,2>(
305 [&](const dpd_marray_view<const double,4>& v, len_type i, len_type j)
306 {
307 bool found = false;
308 for (int m = 0;m < 3;m++)
309 {
310 if (i == indices[m][0] && j == indices[m][1])
311 {
312 EXPECT_EQ(v2.data(m), v.data());
313 found = true;
314 visited[m]++;
315 }
316 }
317 EXPECT_TRUE(found);
318 EXPECT_EQ(1u, v.irrep());
319 EXPECT_EQ(2u, v.num_irreps());
320 EXPECT_EQ((*reinterpret_cast<std::array<unsigned,4>*>(perms[0].data())), v.permutation());
321 EXPECT_EQ((std::array<std::array<len_type,8>,4>{{{3, 1}, {2, 2}, {1, 2}, {3, 4}}}), v.lengths());
322 });
323
324 for (len_type i = 0;i < 3;i++)
325 {
326 EXPECT_EQ(visited[i], 1);
327 }
328 }
329
TEST(indexed_dpd_varray,element_iteration)330 TEST(indexed_dpd_varray, element_iteration)
331 {
332 array<len_vector,3> indices = {{{0, 0}, {1, 3}, {0, 3}}};
333 array<array<int,3>,31> visited;
334 array<len_vector,5> len = {{{2, 3}, {1, 2}, {3, 1}, {2, 2}, {4, 5}}};
335
336 indexed_dpd_varray<double> v1(0, 2, len, vector<int>{1, 1}, indices, 1.0, layouts[0]);
337 const indexed_dpd_varray<double> v2(v1);
338
339 visited = {};
340 v1.for_each_element(
341 [&](double& v, const irrep_vector& irreps, const len_vector& idx)
342 {
343 EXPECT_EQ(irreps.size(), 5u);
344 EXPECT_EQ(idx.size(), 5u);
345 unsigned a = irreps[0];
346 unsigned b = irreps[1];
347 unsigned c = irreps[2];
348 unsigned d = irreps[3];
349 unsigned e = irreps[4];
350 EXPECT_LT(a, 2u);
351 EXPECT_LT(b, 2u);
352 EXPECT_LT(c, 2u);
353 EXPECT_EQ(d, 1u);
354 EXPECT_EQ(e, 1u);
355 EXPECT_EQ(a^b^c^d^e, 0u);
356 len_type i = idx[0];
357 len_type j = idx[1];
358 len_type k = idx[2];
359 len_type l = idx[3];
360 len_type m = idx[4];
361 EXPECT_GE(i, 0);
362 EXPECT_LT(i, len[0][a]);
363 EXPECT_GE(j, 0);
364 EXPECT_LT(j, len[1][b]);
365 EXPECT_GE(k, 0);
366 EXPECT_LT(k, len[2][c]);
367 bool found = false;
368 for (int n = 0;n < 3;n++)
369 {
370 if (l == indices[n][0] && m == indices[n][1])
371 {
372 auto v3 = v1[n](a, b, c);
373 EXPECT_EQ(&v, &v3(i, j, k));
374 visited[&v - v1.data(n)][n]++;
375 found = true;
376 }
377 }
378 EXPECT_TRUE(found);
379 });
380
381 for (len_type i = 0;i < 31;i++)
382 {
383 for (len_type j = 0;j < 3;j++)
384 {
385 EXPECT_EQ(visited[i][j], 1);
386 }
387 }
388
389 visited = {};
390 v2.for_each_element(
391 [&](const double& v, const irrep_vector& irreps, const len_vector& idx)
392 {
393 EXPECT_EQ(irreps.size(), 5u);
394 EXPECT_EQ(idx.size(), 5u);
395 unsigned a = irreps[0];
396 unsigned b = irreps[1];
397 unsigned c = irreps[2];
398 unsigned d = irreps[3];
399 unsigned e = irreps[4];
400 EXPECT_LT(a, 2u);
401 EXPECT_LT(b, 2u);
402 EXPECT_LT(c, 2u);
403 EXPECT_EQ(d, 1u);
404 EXPECT_EQ(e, 1u);
405 EXPECT_EQ(a^b^c^d^e, 0u);
406 len_type i = idx[0];
407 len_type j = idx[1];
408 len_type k = idx[2];
409 len_type l = idx[3];
410 len_type m = idx[4];
411 EXPECT_GE(i, 0);
412 EXPECT_LT(i, len[0][a]);
413 EXPECT_GE(j, 0);
414 EXPECT_LT(j, len[1][b]);
415 EXPECT_GE(k, 0);
416 EXPECT_LT(k, len[2][c]);
417 bool found = false;
418 for (int n = 0;n < 3;n++)
419 {
420 if (l == indices[n][0] && m == indices[n][1])
421 {
422 auto v3 = v2[n](a, b, c);
423 EXPECT_EQ(&v, &v3(i, j, k));
424 visited[&v - v2.data(n)][n]++;
425 found = true;
426 }
427 }
428 EXPECT_TRUE(found);
429 });
430
431 for (len_type i = 0;i < 31;i++)
432 {
433 for (len_type j = 0;j < 3;j++)
434 {
435 EXPECT_EQ(visited[i][j], 1);
436 }
437 }
438
439 visited = {};
440 v1.for_each_element<3,2>(
441 [&](double& v, unsigned a, unsigned b, unsigned c, unsigned d, unsigned e,
442 len_type i, len_type j, len_type k, len_type l, len_type m)
443 {
444 EXPECT_LT(a, 2u);
445 EXPECT_LT(b, 2u);
446 EXPECT_LT(c, 2u);
447 EXPECT_EQ(d, 1u);
448 EXPECT_EQ(e, 1u);
449 EXPECT_EQ(a^b^c^d^e, 0u);
450 EXPECT_GE(i, 0);
451 EXPECT_LT(i, len[0][a]);
452 EXPECT_GE(j, 0);
453 EXPECT_LT(j, len[1][b]);
454 EXPECT_GE(k, 0);
455 EXPECT_LT(k, len[2][c]);
456 bool found = false;
457 for (int n = 0;n < 3;n++)
458 {
459 if (l == indices[n][0] && m == indices[n][1])
460 {
461 auto v3 = v1[n](a, b, c);
462 EXPECT_EQ(&v, &v3(i, j, k));
463 visited[&v - v1.data(n)][n]++;
464 found = true;
465 }
466 }
467 EXPECT_TRUE(found);
468 });
469
470 for (len_type i = 0;i < 31;i++)
471 {
472 for (len_type j = 0;j < 3;j++)
473 {
474 EXPECT_EQ(visited[i][j], 1);
475 }
476 }
477
478 visited = {};
479 v2.for_each_element<3,2>(
480 [&](const double& v, unsigned a, unsigned b, unsigned c, unsigned d, unsigned e,
481 len_type i, len_type j, len_type k, len_type l, len_type m)
482 {
483 EXPECT_LT(a, 2u);
484 EXPECT_LT(b, 2u);
485 EXPECT_LT(c, 2u);
486 EXPECT_EQ(d, 1u);
487 EXPECT_EQ(e, 1u);
488 EXPECT_EQ(a^b^c^d^e, 0u);
489 EXPECT_GE(i, 0);
490 EXPECT_LT(i, len[0][a]);
491 EXPECT_GE(j, 0);
492 EXPECT_LT(j, len[1][b]);
493 EXPECT_GE(k, 0);
494 EXPECT_LT(k, len[2][c]);
495 bool found = false;
496 for (int n = 0;n < 3;n++)
497 {
498 if (l == indices[n][0] && m == indices[n][1])
499 {
500 auto v3 = v2[n](a, b, c);
501 EXPECT_EQ(&v, &v3(i, j, k));
502 visited[&v - v2.data(n)][n]++;
503 found = true;
504 }
505 }
506 EXPECT_TRUE(found);
507 });
508
509 for (len_type i = 0;i < 31;i++)
510 {
511 for (len_type j = 0;j < 3;j++)
512 {
513 EXPECT_EQ(visited[i][j], 1);
514 }
515 }
516 }
517
TEST(indexed_dpd_varray,swap)518 TEST(indexed_dpd_varray, swap)
519 {
520 indexed_dpd_varray<double> v1(1, 2, {{3, 1}, {2, 2}, {1, 2}, {3, 4}, {2, 2}, {4, 5}},
521 {1, 1}, {{0, 0}, {1, 3}, {0, 3}}, 1.0, layouts[0]);
522 indexed_dpd_varray<double> v2(0, 2, {{2, 3}, {1, 2}, {3, 1}, {2, 2}, {4, 5}},
523 {1, 0}, {{0, 0}, {1, 0}, {1, 2}}, 1.0, layouts[0]);
524
525 auto data1 = v1.data();
526 auto data2 = v2.data();
527
528 EXPECT_EQ(6u, v1.dimension());
529 EXPECT_EQ(4u, v1.dense_dimension());
530 EXPECT_EQ(2u, v1.indexed_dimension());
531 EXPECT_EQ((matrix<len_type>{{3, 1}, {2, 2}, {1, 2}, {3, 4}, {2, 2}, {4, 5}}), v1.lengths());
532 EXPECT_EQ((matrix<len_type>{{3, 1}, {2, 2}, {1, 2}, {3, 4}}), v1.dense_lengths());
533 EXPECT_EQ((len_vector{2, 5}), v1.indexed_lengths());
534 EXPECT_EQ(3u, v1.num_indices());
535 EXPECT_EQ((irrep_vector{1, 1}), v1.indexed_irreps());
536 EXPECT_EQ((matrix<len_type>{{0, 0}, {1, 3}, {0, 3}}), v1.indices());
537 EXPECT_EQ(1u, v1.irrep());
538 EXPECT_EQ(2u, v1.num_irreps());
539
540 EXPECT_EQ(5u, v2.dimension());
541 EXPECT_EQ(3u, v2.dense_dimension());
542 EXPECT_EQ(2u, v2.indexed_dimension());
543 EXPECT_EQ((matrix<len_type>{{2, 3}, {1, 2}, {3, 1}, {2, 2}, {4, 5}}), v2.lengths());
544 EXPECT_EQ((matrix<len_type>{{2, 3}, {1, 2}, {3, 1}}), v2.dense_lengths());
545 EXPECT_EQ((len_vector{2, 4}), v2.indexed_lengths());
546 EXPECT_EQ(3u, v2.num_indices());
547 EXPECT_EQ((irrep_vector{1, 0}), v2.indexed_irreps());
548 EXPECT_EQ((matrix<len_type>{{0, 0}, {1, 0}, {1, 2}}), v2.indices());
549 EXPECT_EQ(0u, v2.irrep());
550 EXPECT_EQ(2u, v2.num_irreps());
551
552 v1.swap(v2);
553
554 EXPECT_EQ(6u, v2.dimension());
555 EXPECT_EQ(4u, v2.dense_dimension());
556 EXPECT_EQ(2u, v2.indexed_dimension());
557 EXPECT_EQ((matrix<len_type>{{3, 1}, {2, 2}, {1, 2}, {3, 4}, {2, 2}, {4, 5}}), v2.lengths());
558 EXPECT_EQ((matrix<len_type>{{3, 1}, {2, 2}, {1, 2}, {3, 4}}), v2.dense_lengths());
559 EXPECT_EQ((len_vector{2, 5}), v2.indexed_lengths());
560 EXPECT_EQ(3u, v2.num_indices());
561 EXPECT_EQ((irrep_vector{1, 1}), v2.indexed_irreps());
562 EXPECT_EQ((matrix<len_type>{{0, 0}, {1, 3}, {0, 3}}), v2.indices());
563 EXPECT_EQ(1u, v2.irrep());
564 EXPECT_EQ(2u, v2.num_irreps());
565
566 EXPECT_EQ(5u, v1.dimension());
567 EXPECT_EQ(3u, v1.dense_dimension());
568 EXPECT_EQ(2u, v1.indexed_dimension());
569 EXPECT_EQ((matrix<len_type>{{2, 3}, {1, 2}, {3, 1}, {2, 2}, {4, 5}}), v1.lengths());
570 EXPECT_EQ((matrix<len_type>{{2, 3}, {1, 2}, {3, 1}}), v1.dense_lengths());
571 EXPECT_EQ((len_vector{2, 4}), v1.indexed_lengths());
572 EXPECT_EQ(3u, v1.num_indices());
573 EXPECT_EQ((irrep_vector{1, 0}), v1.indexed_irreps());
574 EXPECT_EQ((matrix<len_type>{{0, 0}, {1, 0}, {1, 2}}), v1.indices());
575 EXPECT_EQ(0u, v1.irrep());
576 EXPECT_EQ(2u, v1.num_irreps());
577
578 swap(v2, v1);
579
580 EXPECT_EQ(6u, v1.dimension());
581 EXPECT_EQ(4u, v1.dense_dimension());
582 EXPECT_EQ(2u, v1.indexed_dimension());
583 EXPECT_EQ((matrix<len_type>{{3, 1}, {2, 2}, {1, 2}, {3, 4}, {2, 2}, {4, 5}}), v1.lengths());
584 EXPECT_EQ((matrix<len_type>{{3, 1}, {2, 2}, {1, 2}, {3, 4}}), v1.dense_lengths());
585 EXPECT_EQ((len_vector{2, 5}), v1.indexed_lengths());
586 EXPECT_EQ(3u, v1.num_indices());
587 EXPECT_EQ((irrep_vector{1, 1}), v1.indexed_irreps());
588 EXPECT_EQ((matrix<len_type>{{0, 0}, {1, 3}, {0, 3}}), v1.indices());
589 EXPECT_EQ(1u, v1.irrep());
590 EXPECT_EQ(2u, v1.num_irreps());
591
592 EXPECT_EQ(5u, v2.dimension());
593 EXPECT_EQ(3u, v2.dense_dimension());
594 EXPECT_EQ(2u, v2.indexed_dimension());
595 EXPECT_EQ((matrix<len_type>{{2, 3}, {1, 2}, {3, 1}, {2, 2}, {4, 5}}), v2.lengths());
596 EXPECT_EQ((matrix<len_type>{{2, 3}, {1, 2}, {3, 1}}), v2.dense_lengths());
597 EXPECT_EQ((len_vector{2, 4}), v2.indexed_lengths());
598 EXPECT_EQ(3u, v2.num_indices());
599 EXPECT_EQ((irrep_vector{1, 0}), v2.indexed_irreps());
600 EXPECT_EQ((matrix<len_type>{{0, 0}, {1, 0}, {1, 2}}), v2.indices());
601 EXPECT_EQ(0u, v2.irrep());
602 EXPECT_EQ(2u, v2.num_irreps());
603 }
604