OpenFPM_pdata  4.1.0
Project that contain the implementation of distributed structures
 
Loading...
Searching...
No Matches
HyperCube_unit_test.hpp
1#ifndef HYPERCUBE_UNIT_TEST_HPP
2#define HYPERCUBE_UNIT_TEST_HPP
3
4#include "Space/Shape/HyperCube.hpp"
5#include "util/util_debug.hpp"
6
13template<unsigned int dim> void check_lin(std::vector<comb<dim>> cmb)
14{
15 // Check the linearization
16 for (size_t i = 0 ; i < cmb.size() ; i++)
17 {
18 BOOST_REQUIRE_EQUAL(HyperCube<dim>::LinId(cmb[i]),i);
19 }
20}
21
28template<unsigned int dim> void check_lin_perm(std::vector<comb<dim>> cmb)
29{
30 // Check the linearization
31 for (size_t i = 0 ; i < cmb.size() ; i++)
32 {
33 BOOST_REQUIRE_EQUAL(HyperCube<dim>::LinPerm(cmb[i]),i);
34 }
35}
36
43template<unsigned int dim> bool isDinstict(std::vector<comb<dim>> combs)
44{
45 // Check if the combination are dinstinct
46
47 for (size_t i = 0 ; i < combs.size() ; i++)
48 {
49 for (size_t j = i+1 ; j < combs.size() ; j++)
50 {
51 if (combs[i] == combs[j])
52 return false;
53 }
54
55 }
56
57 return true;
58}
59
69template<unsigned int dim> bool isSubdecomposition(std::vector<comb<dim>> combs, comb<dim> c)
70{
71 for (size_t i = 0 ; i < combs.size() ; i++)
72 {
73 if (c.isSub(combs[i]) == false)
74 return false;
75 }
76
77 return true;
78}
79
80template<unsigned int dim> bool isValid(std::vector<comb<dim>> combs)
81{
82 // Check if the combinations are valid
83
84 for (size_t i = 0 ; i < combs.size() ; i++)
85 {
86 if (combs[i].isValid() == false)
87 return false;
88 }
89
90 return true;
91}
92
93BOOST_AUTO_TEST_SUITE( Hyper_cube )
94
95BOOST_AUTO_TEST_CASE( Hyper_cube_comb_use )
96{
97 {
98 comb<3> c1({1,2,3});
99 comb<3> c2({1,1,1});
100
101 comb<3> c_ret = c1 - c2;
102
103 BOOST_REQUIRE_EQUAL(c_ret.c[0],2);
104 BOOST_REQUIRE_EQUAL(c_ret.c[1],1);
105 BOOST_REQUIRE_EQUAL(c_ret.c[2],0);
106 }
107
108 {
109 comb<3> c1({1,2,3});
110 comb<3> c2;
111 c2 = c1 & 0x01;
112
113 BOOST_REQUIRE_EQUAL(c2.c[0],1);
114 BOOST_REQUIRE_EQUAL(c2.c[1],0);
115 BOOST_REQUIRE_EQUAL(c2.c[2],1);
116 }
117
118 {
119 comb<3> c1({1,2,3});
120 comb<3> c2({1,1,1});
121
122 comb<3> c_ret = c1 + c2;
123
124 BOOST_REQUIRE_EQUAL(c_ret.c[0],4);
125 BOOST_REQUIRE_EQUAL(c_ret.c[1],3);
126 BOOST_REQUIRE_EQUAL(c_ret.c[2],2);
127 }
128
129 {
130 comb<3> c1({1,2,3});
131
132 comb<3> c_ret = -c1;
133
134 BOOST_REQUIRE_EQUAL(c_ret.c[0],-3);
135 BOOST_REQUIRE_EQUAL(c_ret.c[1],-2);
136 BOOST_REQUIRE_EQUAL(c_ret.c[2],-1);
137 }
138
139 {
140 comb<3> c1({(char)-1,(char)1,(char)0});
141
142 comb<3> c_ret = c1.flip();
143
144 BOOST_REQUIRE_EQUAL(c_ret.c[0],0);
145 BOOST_REQUIRE_EQUAL(c_ret.c[1],-1);
146 BOOST_REQUIRE_EQUAL(c_ret.c[2],-1);
147 }
148}
149
150BOOST_AUTO_TEST_CASE( Hyper_cube_use)
151{
152 std::cout << "Hyper-cube unit test start" << "\n";
153 // Test Hyper-Cube functionality
154
155 size_t ele[8];
156
158
159 // Get the number of vertex (elements of dimension 0) of a line (dimension 1)
160 ele[0] = HyperCube<1>::getNumberOfElements_R(0);
161 // Get the number of edge (elements of dimension 1) of a line (dimension 1)
162 ele[1] = HyperCube<1>::getNumberOfElements_R(1);
163
164 // Get combination for each dimensions
165 std::vector<comb<1>> v_c1_0 = HyperCube<1>::getCombinations_R(0);
166
168
169 // Check
170 BOOST_REQUIRE_EQUAL(ele[0],2ul);
171 BOOST_REQUIRE_EQUAL(ele[1],1ul);
172
173 // Fill the expected vector
174
175 comb<1> c[] = {{(char)1},{(char)-1}};
176
177 // Check the linearization
178 check_lin(v_c1_0);
179
180 std::vector<comb<1>> v1_st;
181 HyperCube<1>::BinPermutationsSt(v1_st);
182 check_lin_perm(v1_st);
183
184 boost_check_array(&c[0],&v_c1_0[0],2);
185
187 // Number of vertex
188 ele[0] = HyperCube<2>::getNumberOfElements_R(0);
189 // Number of edge
190 ele[1] = HyperCube<2>::getNumberOfElements_R(1);
191 // Number of faces
192 ele[2] = HyperCube<2>::getNumberOfElements_R(2);
193
194 // Get combination for vertex (1,1) (-1,1) (-1,1) (-1,-1)
195 std::vector<comb<2>> v_c2_0 = HyperCube<2>::getCombinations_R(0);
196 // Get combination for edges (1,0) (-1,0) (0,1) (0,-1)
197 std::vector<comb<2>> v_c2_1 = HyperCube<2>::getCombinations_R(1);
198
200
201 // Check
202 BOOST_REQUIRE_EQUAL(ele[0],4ul);
203 BOOST_REQUIRE_EQUAL(ele[1],4ul);
204 BOOST_REQUIRE_EQUAL(ele[2],1ul);
205
206 // Check combination
207
208 comb<2> c2_0[] = {{(char)1,(char)1},{(char)-1,(char)1},{(char)1,(char)-1},{(char)-1,(char)-1}};
209 comb<2> c2_1[] = {{(char)0,(char)1},{(char)0,(char)-1},{(char)1,(char)0},{(char)-1,(char)0}};
210 check_lin(v_c2_0);
211 check_lin(v_c2_1);
212
213 std::vector<comb<2>> v2_st;
214 HyperCube<2>::BinPermutationsSt(v2_st);
215 check_lin_perm(v2_st);
216
217 boost_check_array(&c2_0[0],&v_c2_0[0],4);
218 boost_check_array(&c2_1[0],&v_c2_1[0],4);
219
221 // Number of vertex
222 ele[0] = HyperCube<3>::getNumberOfElements_R(0);
223 // Number of edge
224 ele[1] = HyperCube<3>::getNumberOfElements_R(1);
225 // Number of faces
226 ele[2] = HyperCube<3>::getNumberOfElements_R(2);
227 // Number of Cubes
228 ele[3] = HyperCube<3>::getNumberOfElements_R(3);
229
230 // Get combination for vertex
231 std::vector<comb<3>> v_c3_0 = HyperCube<3>::getCombinations_R(0);
232 // Get combinations for edge
233 std::vector<comb<3>> v_c3_1 = HyperCube<3>::getCombinations_R(1);
234 // Get combinations for surfaces
235 std::vector<comb<3>> v_c3_2 = HyperCube<3>::getCombinations_R(2);
236
238
239 // Check
240 BOOST_REQUIRE_EQUAL(ele[0],8ul);
241 BOOST_REQUIRE_EQUAL(ele[1],12ul);
242 BOOST_REQUIRE_EQUAL(ele[2],6ul);
243 BOOST_REQUIRE_EQUAL(ele[3],1ul);
244
245 // Check combination
246
247 comb<3> c3_0[] = {{(char)1,(char)1,(char)1},{(char)-1,(char)1,(char)1},{(char)1,(char)-1,(char)1},{(char)-1,(char)-1,(char)1},{(char)1,(char)1,(char)-1},{(char)-1,(char)1,(char)-1},{(char)1,(char)-1,(char)-1},{(char)-1,(char)-1,(char)-1}};
248 comb<3> c3_1[] = {{(char)0,(char)1,(char)1},{(char)0,(char)-1,(char)1},{(char)0,(char)1,(char)-1},{(char)0,(char)-1,(char)-1},{(char)1,(char)0,(char)1},{(char)-1,(char)0,(char)1},{(char)1,(char)0,(char)-1},{(char)-1,(char)0,(char)-1},{(char)1,(char)1,(char)0},{(char)-1,(char)1,(char)0},{(char)1,(char)-1,(char)0},{(char)-1,(char)-1,(char)0}};
249 comb<3> c3_2[] = {{{(char)0,(char)0,(char)1}},{{(char)0,(char)0,(char)-1}},{{(char)0,(char)1,(char)0}},{{(char)0,(char)-1,(char)0}},{{(char)1,(char)0,(char)0}},{{(char)-1,(char)0,(char)0}}};
250 check_lin(v_c3_0);
251 check_lin(v_c3_1);
252 check_lin(v_c3_2);
253
254 std::vector<comb<3>> v3_st;
255 HyperCube<3>::BinPermutationsSt(v3_st);
256 check_lin_perm(v3_st);
257
258 boost_check_array(&c3_0[0],&v_c3_0[0],8);
259 boost_check_array(&c3_1[0],&v_c3_1[0],12);
260 boost_check_array(&c3_2[0],&v_c3_2[0],6);
261
262 // Tesseract
263 // Number of vertex
264 ele[0] = HyperCube<4>::getNumberOfElements_R(0);
265 // Number of edge
266 ele[1] = HyperCube<4>::getNumberOfElements_R(1);
267 // Number of faces
268 ele[2] = HyperCube<4>::getNumberOfElements_R(2);
269 // Number of Cubes
270 ele[3] = HyperCube<4>::getNumberOfElements_R(3);
271 // Number of Tessaract
272 ele[4] = HyperCube<4>::getNumberOfElements_R(4);
273
274 // Get combination for each dimensions
275 std::vector<comb<4>> v_c4_0 = HyperCube<4>::getCombinations_R(0);
276 std::vector<comb<4>> v_c4_1 = HyperCube<4>::getCombinations_R(1);
277 std::vector<comb<4>> v_c4_2 = HyperCube<4>::getCombinations_R(2);
278 std::vector<comb<4>> v_c4_3 = HyperCube<4>::getCombinations_R(3);
279 check_lin(v_c4_0);
280 check_lin(v_c4_1);
281 check_lin(v_c4_2);
282 check_lin(v_c4_3);
283
284 std::vector<comb<4>> v4_st;
285 HyperCube<4>::BinPermutationsSt(v4_st);
286 check_lin_perm(v1_st);
287
288 // Check
289 BOOST_REQUIRE_EQUAL(ele[0],16ul);
290 BOOST_REQUIRE_EQUAL(ele[1],32ul);
291 BOOST_REQUIRE_EQUAL(ele[2],24ul);
292 BOOST_REQUIRE_EQUAL(ele[3],8ul);
293 BOOST_REQUIRE_EQUAL(ele[4],1ul);
294
295 // Penteract
296 // Number of vertex
297 ele[0] = HyperCube<5>::getNumberOfElements_R(0);
298 // Number of edge
299 ele[1] = HyperCube<5>::getNumberOfElements_R(1);
300 // Number of faces
301 ele[2] = HyperCube<5>::getNumberOfElements_R(2);
302 // Number of Cubes
303 ele[3] = HyperCube<5>::getNumberOfElements_R(3);
304 // Number of Tessaract
305 ele[4] = HyperCube<5>::getNumberOfElements_R(4);
306 // Number of Penteract
307 ele[5] = HyperCube<5>::getNumberOfElements_R(5);
308
309 // Get combination for each dimensions
310 std::vector<comb<5>> v_c5_0 = HyperCube<5>::getCombinations_R(0);
311 std::vector<comb<5>> v_c5_1 = HyperCube<5>::getCombinations_R(1);
312 std::vector<comb<5>> v_c5_2 = HyperCube<5>::getCombinations_R(2);
313 std::vector<comb<5>> v_c5_3 = HyperCube<5>::getCombinations_R(3);
314 std::vector<comb<5>> v_c5_4 = HyperCube<5>::getCombinations_R(4);
315 check_lin(v_c5_0);
316 check_lin(v_c5_1);
317 check_lin(v_c5_2);
318 check_lin(v_c5_3);
319 check_lin(v_c5_4);
320
321 std::vector<comb<5>> v5_st;
322 HyperCube<5>::BinPermutationsSt(v5_st);
323 check_lin_perm(v5_st);
324
325 // Check
326 BOOST_REQUIRE_EQUAL(ele[0],32ul);
327 BOOST_REQUIRE_EQUAL(ele[1],80ul);
328 BOOST_REQUIRE_EQUAL(ele[2],80ul);
329 BOOST_REQUIRE_EQUAL(ele[3],40ul);
330 BOOST_REQUIRE_EQUAL(ele[4],10ul);
331 BOOST_REQUIRE_EQUAL(ele[5],1ul);
332
333
334 // Test SubHypercube 2D and 3D
335
337 std::vector<comb<2>> sc2_0 = HyperCube<2>::getCombinations_R(0);
339
340 for (size_t i = 0 ; i < sc2_0.size() ; i++)
341 {
342 // Expecting one element equal to c2[i]
344 std::vector<comb<2>> combs = SubHyperCube<2,0>::getCombinations_R(sc2_0[i],0);
346 BOOST_REQUIRE_EQUAL(combs.size(),1ul);
347 BOOST_REQUIRE_EQUAL(isDinstict(combs),true);
348 BOOST_REQUIRE_EQUAL(isValid(combs),true);
349 BOOST_REQUIRE_EQUAL(isSubdecomposition(combs,sc2_0[i]),true);
350 }
351
353 std::vector<comb<2>> sc2_1 = HyperCube<2>::getCombinations_R(1);
355
356 for (size_t i = 0 ; i < sc2_1.size() ; i++)
357 {
358 // Expecting two elements, valid, distinct, sub-decomposition of c2[i]
359
361 std::vector<comb<2>> combs = SubHyperCube<2,1>::getCombinations_R(sc2_1[i],0);
363 BOOST_REQUIRE_EQUAL(combs.size(),2ul);
364 BOOST_REQUIRE_EQUAL(isDinstict(combs),true);
365 BOOST_REQUIRE_EQUAL(isValid(combs),true);
366 BOOST_REQUIRE_EQUAL(isSubdecomposition(combs,sc2_1[i]),true);
367
368 // Expecting one element, valid, distinct, sub-decomposition of c2[i]
370 combs = SubHyperCube<2,1>::getCombinations_R(sc2_1[i],1);
372 BOOST_REQUIRE_EQUAL(combs.size(),1ul);
373 BOOST_REQUIRE_EQUAL(isDinstict(combs),true);
374 BOOST_REQUIRE_EQUAL(isValid(combs),true);
375 BOOST_REQUIRE_EQUAL(isSubdecomposition(combs,sc2_1[i]),true);
376 }
377
379 std::vector<comb<2>> sc2_2 = HyperCube<2>::getCombinations_R(2);
381
382 for (size_t i = 0 ; i < sc2_2.size() ; i++)
383 {
384 // Expecting two elements, valid, distinct, sub-decomposition of sc2_2[i]
386 std::vector<comb<2>> combs = SubHyperCube<2,2>::getCombinations_R(sc2_2[i],0);
388 BOOST_REQUIRE_EQUAL(combs.size(),4ul);
389 BOOST_REQUIRE_EQUAL(isDinstict(combs),true);
390 BOOST_REQUIRE_EQUAL(isValid(combs),true);
391 BOOST_REQUIRE_EQUAL(isSubdecomposition(combs,sc2_2[i]),true);
392
393 // Expecting one element, valid, distinct, sub-decomposition of c2[i]
395 combs = SubHyperCube<2,2>::getCombinations_R(sc2_2[i],1);
397 BOOST_REQUIRE_EQUAL(combs.size(),4ul);
398 BOOST_REQUIRE_EQUAL(isDinstict(combs),true);
399 BOOST_REQUIRE_EQUAL(isValid(combs),true);
400 BOOST_REQUIRE_EQUAL(isSubdecomposition(combs,sc2_2[i]),true);
401
402 // Expecting one element, valid, distinct, sub-decomposition of c2[i]
404 combs = SubHyperCube<2,2>::getCombinations_R(sc2_2[i],2);
406 BOOST_REQUIRE_EQUAL(combs.size(),1ul);
407 BOOST_REQUIRE_EQUAL(isDinstict(combs),true);
408 BOOST_REQUIRE_EQUAL(isValid(combs),true);
409 BOOST_REQUIRE_EQUAL(isSubdecomposition(combs,sc2_2[i]),true);
410 }
411
413
415 std::vector<comb<3>> sc3_0 = HyperCube<3>::getCombinations_R(0);
417
418 for (size_t i = 0 ; i < sc3_0.size() ; i++)
419 {
420 // Expecting one element equal to sc3[i]
422 std::vector<comb<3>> combs = SubHyperCube<3,0>::getCombinations_R(sc3_0[i],0);
424 BOOST_REQUIRE_EQUAL(combs.size(),1ul);
425 BOOST_REQUIRE_EQUAL(isDinstict(combs),true);
426 BOOST_REQUIRE_EQUAL(isValid(combs),true);
427// BOOST_REQUIRE_EQUAL(isSubdecomposition(combs,sc3_0[i]),true);
428 }
429
431 std::vector<comb<3>> sc3_1 = HyperCube<3>::getCombinations_R(1);
433
434 for (size_t i = 0 ; i < sc3_1.size() ; i++)
435 {
436 // Expecting two elements, valid, distinct, sub-decomposition of sc3[i]
438 std::vector<comb<3>> combs = SubHyperCube<3,1>::getCombinations_R(sc3_1[i],0);
440 BOOST_REQUIRE_EQUAL(combs.size(),2ul);
441 BOOST_REQUIRE_EQUAL(isDinstict(combs),true);
442 BOOST_REQUIRE_EQUAL(isValid(combs),true);
443 BOOST_REQUIRE_EQUAL(isSubdecomposition(combs,sc3_1[i]),true);
444
445 // Expecting one element, valid, distinct, sub-decomposition of c2[i]
447 combs = SubHyperCube<3,1>::getCombinations_R(sc3_1[i],1);
449 BOOST_REQUIRE_EQUAL(combs.size(),1ul);
450 BOOST_REQUIRE_EQUAL(isDinstict(combs),true);
451 BOOST_REQUIRE_EQUAL(isValid(combs),true);
452 BOOST_REQUIRE_EQUAL(isSubdecomposition(combs,sc3_1[i]),true);
453 }
454
456 std::vector<comb<3>> sc3_2 = HyperCube<3>::getCombinations_R(2);
458
459 for (size_t i = 0 ; i < sc3_2.size() ; i++)
460 {
461 // Expecting two elements, valid, distinct, sub-decomposition of sc3_2[i]
463 std::vector<comb<3>> combs = SubHyperCube<3,2>::getCombinations_R(sc3_2[i],0);
465 BOOST_REQUIRE_EQUAL(combs.size(),4ul);
466 BOOST_REQUIRE_EQUAL(isDinstict(combs),true);
467 BOOST_REQUIRE_EQUAL(isValid(combs),true);
468 BOOST_REQUIRE_EQUAL(isSubdecomposition(combs,sc3_2[i]),true);
469
470 // Expecting one element, valid, distinct, sub-decomposition of c2[i]
472 combs = SubHyperCube<3,2>::getCombinations_R(sc3_2[i],1);
474 BOOST_REQUIRE_EQUAL(combs.size(),4ul);
475 BOOST_REQUIRE_EQUAL(isDinstict(combs),true);
476 BOOST_REQUIRE_EQUAL(isValid(combs),true);
477 BOOST_REQUIRE_EQUAL(isSubdecomposition(combs,sc3_2[i]),true);
478
479 // Expecting one element, valid, distinct, sub-decomposition of c2[i]
481 combs = SubHyperCube<3,2>::getCombinations_R(sc3_2[i],2);
483 BOOST_REQUIRE_EQUAL(combs.size(),1ul);
484 BOOST_REQUIRE_EQUAL(isDinstict(combs),true);
485 BOOST_REQUIRE_EQUAL(isValid(combs),true);
486 BOOST_REQUIRE_EQUAL(isSubdecomposition(combs,sc3_2[i]),true);
487 }
488
489 // High dimension test
490 size_t bc[50];
491
492 for (size_t i = 0 ; i < 50 ; i++)
493 {bc[i] = NON_PERIODIC;}
494
495 bc[0] = PERIODIC;
496 bc[11] = PERIODIC;
497 bc[17] = PERIODIC;
498
499 std::vector<comb<50>> sc50_2 = HyperCube<50>::getCombinations_R_bc(49,bc);
500
501 BOOST_REQUIRE_EQUAL(sc50_2.size(),6ul);
502
503 BOOST_REQUIRE_EQUAL(sc50_2[0].c[0],1);
504 BOOST_REQUIRE_EQUAL(sc50_2[0].c[11],0);
505 BOOST_REQUIRE_EQUAL(sc50_2[0].c[17],0);
506
507 BOOST_REQUIRE_EQUAL(sc50_2[1].c[0],-1);
508 BOOST_REQUIRE_EQUAL(sc50_2[1].c[11],0);
509 BOOST_REQUIRE_EQUAL(sc50_2[1].c[17],0);
510
511 BOOST_REQUIRE_EQUAL(sc50_2[2].c[0],0);
512 BOOST_REQUIRE_EQUAL(sc50_2[2].c[11],1);
513 BOOST_REQUIRE_EQUAL(sc50_2[2].c[17],0);
514
515 BOOST_REQUIRE_EQUAL(sc50_2[3].c[0],0);
516 BOOST_REQUIRE_EQUAL(sc50_2[3].c[11],-1);
517 BOOST_REQUIRE_EQUAL(sc50_2[3].c[17],0);
518
519 BOOST_REQUIRE_EQUAL(sc50_2[4].c[0],0);
520 BOOST_REQUIRE_EQUAL(sc50_2[4].c[11],0);
521 BOOST_REQUIRE_EQUAL(sc50_2[4].c[17],1);
522
523 BOOST_REQUIRE_EQUAL(sc50_2[5].c[0],0);
524 BOOST_REQUIRE_EQUAL(sc50_2[5].c[11],0);
525 BOOST_REQUIRE_EQUAL(sc50_2[5].c[17],-1);
526
527 std::vector<comb<50>> sc50_3 = HyperCube<50>::getCombinations_R_bc(48,bc);
528
529 BOOST_REQUIRE_EQUAL(sc50_3.size(),12ul);
530
531 BOOST_REQUIRE_EQUAL(sc50_3[0].c[0],1);
532 BOOST_REQUIRE_EQUAL(sc50_3[0].c[11],1);
533 BOOST_REQUIRE_EQUAL(sc50_3[0].c[17],0);
534
535 BOOST_REQUIRE_EQUAL(sc50_3[1].c[0],1);
536 BOOST_REQUIRE_EQUAL(sc50_3[1].c[11],-1);
537 BOOST_REQUIRE_EQUAL(sc50_3[1].c[17],0);
538
539 BOOST_REQUIRE_EQUAL(sc50_3[2].c[0],-1);
540 BOOST_REQUIRE_EQUAL(sc50_3[2].c[11],1);
541 BOOST_REQUIRE_EQUAL(sc50_3[2].c[17],0);
542
543 BOOST_REQUIRE_EQUAL(sc50_3[3].c[0],-1);
544 BOOST_REQUIRE_EQUAL(sc50_3[3].c[11],-1);
545 BOOST_REQUIRE_EQUAL(sc50_3[3].c[17],0);
546
547 BOOST_REQUIRE_EQUAL(sc50_3[4].c[0],1);
548 BOOST_REQUIRE_EQUAL(sc50_3[4].c[11],0);
549 BOOST_REQUIRE_EQUAL(sc50_3[4].c[17],1);
550
551 BOOST_REQUIRE_EQUAL(sc50_3[5].c[0],1);
552 BOOST_REQUIRE_EQUAL(sc50_3[5].c[11],0);
553 BOOST_REQUIRE_EQUAL(sc50_3[5].c[17],-1);
554
555 BOOST_REQUIRE_EQUAL(sc50_3[6].c[0],-1);
556 BOOST_REQUIRE_EQUAL(sc50_3[6].c[11],0);
557 BOOST_REQUIRE_EQUAL(sc50_3[6].c[17],1);
558
559 BOOST_REQUIRE_EQUAL(sc50_3[7].c[0],-1);
560 BOOST_REQUIRE_EQUAL(sc50_3[7].c[11],0);
561 BOOST_REQUIRE_EQUAL(sc50_3[7].c[17],-1);
562
563 BOOST_REQUIRE_EQUAL(sc50_3[8].c[0],0);
564 BOOST_REQUIRE_EQUAL(sc50_3[8].c[11],1);
565 BOOST_REQUIRE_EQUAL(sc50_3[8].c[17],1);
566
567 BOOST_REQUIRE_EQUAL(sc50_3[9].c[0],0);
568 BOOST_REQUIRE_EQUAL(sc50_3[9].c[11],1);
569 BOOST_REQUIRE_EQUAL(sc50_3[9].c[17],-1);
570
571 BOOST_REQUIRE_EQUAL(sc50_3[10].c[0],0);
572 BOOST_REQUIRE_EQUAL(sc50_3[10].c[11],-1);
573 BOOST_REQUIRE_EQUAL(sc50_3[10].c[17],1);
574
575 BOOST_REQUIRE_EQUAL(sc50_3[11].c[0],0);
576 BOOST_REQUIRE_EQUAL(sc50_3[11].c[11],-1);
577 BOOST_REQUIRE_EQUAL(sc50_3[11].c[17],-1);
578
579 std::vector<comb<50>> sc50_4 = HyperCube<50>::getCombinations_R_bc(47,bc);
580
581 BOOST_REQUIRE_EQUAL(sc50_4.size(),8ul);
582
583 BOOST_REQUIRE_EQUAL(sc50_4[0].c[0],1);
584 BOOST_REQUIRE_EQUAL(sc50_4[0].c[11],1);
585 BOOST_REQUIRE_EQUAL(sc50_4[0].c[17],1);
586
587 BOOST_REQUIRE_EQUAL(sc50_4[1].c[0],1);
588 BOOST_REQUIRE_EQUAL(sc50_4[1].c[11],1);
589 BOOST_REQUIRE_EQUAL(sc50_4[1].c[17],-1);
590
591 BOOST_REQUIRE_EQUAL(sc50_4[2].c[0],1);
592 BOOST_REQUIRE_EQUAL(sc50_4[2].c[11],-1);
593 BOOST_REQUIRE_EQUAL(sc50_4[2].c[17],1);
594
595 BOOST_REQUIRE_EQUAL(sc50_4[3].c[0],1);
596 BOOST_REQUIRE_EQUAL(sc50_4[3].c[11],-1);
597 BOOST_REQUIRE_EQUAL(sc50_4[3].c[17],-1);
598
599 BOOST_REQUIRE_EQUAL(sc50_4[4].c[0],-1);
600 BOOST_REQUIRE_EQUAL(sc50_4[4].c[11],1);
601 BOOST_REQUIRE_EQUAL(sc50_4[4].c[17],1);
602
603 BOOST_REQUIRE_EQUAL(sc50_4[5].c[0],-1);
604 BOOST_REQUIRE_EQUAL(sc50_4[5].c[11],1);
605 BOOST_REQUIRE_EQUAL(sc50_4[5].c[17],-1);
606
607 BOOST_REQUIRE_EQUAL(sc50_4[6].c[0],-1);
608 BOOST_REQUIRE_EQUAL(sc50_4[6].c[11],-1);
609 BOOST_REQUIRE_EQUAL(sc50_4[6].c[17],1);
610
611 BOOST_REQUIRE_EQUAL(sc50_4[7].c[0],-1);
612 BOOST_REQUIRE_EQUAL(sc50_4[7].c[11],-1);
613 BOOST_REQUIRE_EQUAL(sc50_4[7].c[17],-1);
614
615 std::cout << "Hyper-cube unit test end" << "\n";
616}
617
618BOOST_AUTO_TEST_SUITE_END()
619
620#endif
HyperCube
This class calculate elements of the hyper-cube.
Definition HyperCube.hpp:58
HyperCube::getCombinations_R
static std::vector< comb< dim > > getCombinations_R(size_t d)
Definition HyperCube.hpp:100
HyperCube::BinPermutationsSt
static void BinPermutationsSt(std::vector< comb< dim > > &v)
Binary permutations.
Definition HyperCube.hpp:293
HyperCube::getNumberOfElements_R
static size_t getNumberOfElements_R(size_t d)
Get the number of Elements of dimension d.
Definition HyperCube.hpp:67
HyperCube::getCombinations_R_bc
static std::vector< comb< dim > > getCombinations_R_bc(size_t d, const size_t(&bc)[dim])
Definition HyperCube.hpp:151
SubHyperCube::getCombinations_R
static std::vector< comb< dim > > getCombinations_R(comb< dim > c, int d)
Definition HyperCube.hpp:509
comb
Position of the element of dimension d in the hyper-cube of dimension dim.
Definition comb.hpp:35
comb::isSub
bool isSub(comb< dim > cmb)
Check if the combination is a sub-element.
Definition comb.hpp:66
comb::c
signed char c[dim]
Array that store the combination.
Definition comb.hpp:37