Arcane  4.2.1.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
TestNumArray.cc
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2026 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
4// See the top-level COPYRIGHT file for details.
5// SPDX-License-Identifier: Apache-2.0
6//-----------------------------------------------------------------------------
7
8#include <gtest/gtest.h>
9
10#include "arcane/utils/NumArray.h"
11
12#include "arcane/utils/Real2.h"
13#include "arcane/utils/Real3.h"
14#include "arcane/utils/Real2x2.h"
15#include "arcane/utils/Real3x3.h"
16
17#include "arcane/utils/NumArrayUtils.h"
18
19#include <vector>
20
21/*---------------------------------------------------------------------------*/
22/*---------------------------------------------------------------------------*/
23
24using namespace Arcane;
25
26/*---------------------------------------------------------------------------*/
27/*---------------------------------------------------------------------------*/
28
29using namespace Arcane;
30
31TEST(NumArray, Empty)
32{
33 std::cout << "TEST_NUMARRAY Vide\n";
34 NumArray<Real, MDDim1> array1;
35 NumArray<Real, MDDim1> array2(array1);
36 NumArray<Real, MDDim1> array3;
37 array1 = array3;
38 NumArray<Real, MDDim1> array4;
39 array4 = array1;
40}
41
42TEST(NumArray, Basic)
43{
44 std::cout << "TEST_NUMARRAY Basique\n";
45
46 NumArray<Real, MDDim1> array1(3);
47 array1(1) = 5.0;
48 ASSERT_EQ(array1(1), 5.0);
49 std::cout << " V=" << array1(1) << "\n";
50 array1[2] = 3.0;
51 ASSERT_EQ(array1[2], 3.0);
52 std::cout << " V=" << array1(1) << "\n";
53 array1.resize(7);
54 ASSERT_EQ(array1.totalNbElement(), 7);
55
56 NumArray<Real, MDDim2> array2(2, 3);
57 array2(1, 2) = 5.0;
58 std::cout << " V=" << array2(1, 2) << "\n";
59 array2.resize(7, 5);
60 ASSERT_EQ(array2.totalNbElement(), (7 * 5));
61
62 NumArray<Real, MDDim3> array3(2, 3, 4);
63 array3(1, 2, 3) = 5.0;
64 std::cout << " V=" << array3(1, 2, 3) << "\n";
65 ASSERT_EQ(array3(1, 2, 3), 5.0);
66 array3.resize(12, 4, 6);
67 ASSERT_EQ(array3.totalNbElement(), (12 * 4 * 6));
68 array3.fill(0.0);
69 array3(1, 2, 3) = 4.0;
70 array3(2, 3, 5) = 1.0;
71
72 {
73 MDSpan<Real, MDDim3> span_array3(array3.mdspan());
74 ASSERT_EQ(array3.extent0(), span_array3.extent0());
75
76 MDSpan<const Real, MDDim3> const_span_array3(array3.constMDSpan());
77 ASSERT_EQ(const_span_array3.to1DSpan(), span_array3.to1DSpan());
78
79 ASSERT_EQ(array3.extent0(), span_array3.extent0());
80 std::cout << "Array3: extents=" << array3.extent0()
81 << "," << array3.extent1() << "," << array3.extent2() << "\n";
82 for (Int32 i = 0; i < array3.extent0(); ++i) {
83 MDSpan<Real, MDDim2> span_array2 = span_array3.slice(i);
84 ASSERT_EQ(span_array2.extent0(), span_array3.extent1());
85 ASSERT_EQ(span_array2.extent1(), span_array3.extent2());
86 std::cout << " MDDim2 slice i=" << i << " X=" << span_array2.extent0() << " Y=" << span_array2.extent1() << "\n";
87 for (Int32 x = 0, xn = span_array2.extent0(); x < xn; ++x) {
88 for (Int32 y = 0, yn = span_array2.extent1(); y < yn; ++y) {
89 ASSERT_EQ(span_array2.ptrAt(x, y), span_array3.ptrAt(i, x, y));
90 }
91 }
92 }
93 }
94 {
95 MDSpan<Real, MDDim2> span_array2(array2.mdspan());
96 std::cout << "Array2: extents=" << array2.extent0() << "," << array2.extent1() << "\n";
97 for (Int32 i = 0; i < array2.extent0(); ++i) {
98 MDSpan<Real, MDDim1> span_array1 = array2.mdspan().slice(i);
99 ASSERT_EQ(span_array1.extent0(), span_array2.extent1());
100 std::cout << " MDDim1 slice i=" << i << " X=" << span_array2.extent0() << "\n";
101 for (Int32 x = 0, xn = span_array1.extent0(); x < xn; ++x) {
102 ASSERT_EQ(span_array1.ptrAt(x), span_array2.ptrAt(i, x));
103 }
104 }
105 }
106 NumArray<Real, MDDim4> array4(2, 3, 4, 5);
107 array4(1, 2, 3, 4) = 5.0;
108 std::cout << " V=" << array4(1, 2, 3, 4) << "\n";
109 array4.resize(8, 3, 7, 5);
110 ASSERT_EQ(array4.totalNbElement(), (8 * 3 * 7 * 5));
111
112 NumArray<Real, MDDim1> num_data1(4, { 2.4, 5.6, 3.3, 5.4 });
113 ASSERT_EQ(num_data1[0], 2.4);
114 ASSERT_EQ(num_data1[1], 5.6);
115 ASSERT_EQ(num_data1[2], 3.3);
116 ASSERT_EQ(num_data1[3], 5.4);
117
118 NumArray<Real, MDDim2, RightLayout> num_data2(3, 2, { 1.4, 15.6, 33.3, 7.4, 4.2, 6.5 });
119 ASSERT_EQ(num_data2(0, 0), 1.4);
120 ASSERT_EQ(num_data2(0, 1), 15.6);
121 ASSERT_EQ(num_data2(1, 0), 33.3);
122 ASSERT_EQ(num_data2(1, 1), 7.4);
123 ASSERT_EQ(num_data2(2, 0), 4.2);
124 ASSERT_EQ(num_data2(2, 1), 6.5);
125}
126
127/*---------------------------------------------------------------------------*/
128/*---------------------------------------------------------------------------*/
129
130TEST(NumArray, Basic2)
131{
132 std::cout << "TEST_NUMARRAY Basique2\n";
133
134 NumArray<Real, MDDim1> array1;
135 array1.resize(2);
136 array1(1) = 5.0;
137 std::cout << " V=" << array1(1) << "\n";
138
139 NumArray<Real, MDDim2> array2;
140 array2.resize(2, 3);
141 array2(1, 2) = 5.0;
142 std::cout << " V=" << array2(1, 2) << "\n";
143
144 NumArray<Real, MDDim3> array3(2, 3, 4);
145 array3.resize(2, 3, 4);
146 array3(1, 2, 3) = 5.0;
147 std::cout << " V=" << array3(1, 2, 3) << "\n";
148
149 NumArray<Real, MDDim4> array4(2, 3, 4, 5);
150 array4.resize(2, 3, 4, 5);
151 array4(1, 2, 3, 4) = 5.0;
152 std::cout << " V=" << array4(1, 2, 3, 4) << "\n";
153}
154
155/*---------------------------------------------------------------------------*/
156/*---------------------------------------------------------------------------*/
157
158TEST(NumArray, Extents)
159{
160 std::cout << "TEST_NUMARRAY Extents\n";
161
162 ASSERT_EQ(1, (ExtentsV<Int32, -1, 1, 1, 1>::nb_dynamic));
163 ASSERT_EQ(2, (ExtentsV<Int32, -1, DynExtent, 2>::nb_dynamic));
164 ASSERT_EQ(1, (ExtentsV<Int32, DynExtent, 1>::nb_dynamic));
165 ASSERT_EQ(1, (ExtentsV<Int32, -1>::nb_dynamic));
166 ASSERT_EQ(2, (ExtentsV<Int32, DynExtent, DynExtent, 1>::nb_dynamic));
167 ASSERT_EQ(1, MDDim1::nb_dynamic);
168 ASSERT_EQ(2, MDDim2::nb_dynamic);
169 ASSERT_EQ(3, MDDim3::nb_dynamic);
170 ;
171 ASSERT_EQ(4, MDDim4::nb_dynamic);
172
173 {
174 NumArray<int, ExtentsV<Int32, 2, DynExtent, 3, DynExtent>> x1;
175 x1.resize({ 6, 7 });
176 ASSERT_EQ(x1.extent0(), 2);
177 ASSERT_EQ(x1.extent1(), 6);
178 ASSERT_EQ(x1.extent2(), 3);
179 ASSERT_EQ(x1.extent3(), 7);
180 }
181 {
182 NumArray<int, ExtentsV<Int32, 2, 3, DynExtent>> x1;
183 x1.resize(6);
184 ASSERT_EQ(x1.extent0(), 2);
185 ASSERT_EQ(x1.extent1(), 3);
186 ASSERT_EQ(x1.extent2(), 6);
187 }
188}
189
190/*---------------------------------------------------------------------------*/
191/*---------------------------------------------------------------------------*/
192
193TEST(NumArray3, Misc)
194{
195 constexpr int nb_x = 3;
196 constexpr int nb_y = 4;
197 constexpr int nb_z = 5;
198
199 NumArray<Int64, MDDim3> v(nb_x, nb_y, nb_z);
200 v.fill(0);
201 // Attention, v.extents() change si 'v' est redimensionné
202 auto v_extents = v.extentsWithOffset();
203 {
204 for (Int32 x = 0, xn = v.dim1Size(); x < xn; ++x) {
205 for (Int32 y = 0, yn = v.dim2Size(); y < yn; ++y) {
206 for (Int32 z = 0, zn = v.dim3Size(); z < zn; ++z) {
207 ArrayIndex<3> idx{ x, y, z };
208 Int64 offset = v_extents.offset(idx);
209 v(x, y, z) = offset;
210 v({ x, y, z }) = offset;
211 v(idx) = offset;
212 }
213 }
214 }
215 }
216 std::cout << "CAPACITY V1=" << v.capacity() << "\n";
217 v.resize(4, 5, 6);
218 std::cout << "CAPACITY V2=" << v.capacity() << "\n";
219 v.resize(2, 7, 9);
220 std::cout << "CAPACITY V3=" << v.capacity() << "\n";
221 v.resize(3, 2, 6);
222 std::cout << "CAPACITY V4=" << v.capacity() << "\n";
223
224 ASSERT_EQ(v.data(), v.to1DSpan().data());
225
226 {
227 // Check iterators
228 NumArray<Int32, MDDim1> array1(4);
229 Int32 base = 2;
230 Int32 total = 0;
231 for( Int32& x : array1 ){
232 x = base;
233 ++base;
234 }
235 const auto& const_array1 = array1;
236 for( Int32 x : const_array1 )
237 total += x;
238 ASSERT_EQ(total,14);
239 }
240
241 // NOTE: désactive temporairement le test tant que la méthode
242 // resize() de 'NumArray' ne conserve pas les valeurs
243#if NUMARRAY_HAS_VALID_RESIZE
244 // Les valeurs ci-dessous dépendent de l'implémentation actuelle
245 // de NumArray::resize(). Je ne suis pas sur qu'il soit valide de les
246 // tester
247 std::vector<Int64> valid_values = {
248 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
249 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
250 24, 25, 26, 27, 28, 29, 20, 21, 22, 23, 24, 25
251 };
252 ASSERT_EQ(valid_values.size(), (size_t)36);
253
254 v_extents = v.extentsWithOffset();
255 Int64 index = 0;
256 for (Int64 x = 0, xn = v.dim1Size(); x < xn; ++x) {
257 for (Int64 y = 0, yn = v.dim2Size(); y < yn; ++y) {
258 for (Int64 z = 0, zn = v.dim3Size(); z < zn; ++z) {
259 ArrayBoundsIndex<3> idx{ x, y, z };
260 Int64 offset = v_extents.offset(idx);
261 Int64 val1 = v(x, y, z);
262 Int64 val2 = v({ x, y, z });
263 std::cout << "XYZ=" << x << " " << y << " " << z
264 << " V=" << val1 << " offset=" << offset << "\n";
265 ASSERT_EQ(index, offset);
266 ASSERT_EQ(val1, val2);
267 ASSERT_EQ(valid_values.at(offset), val1);
268 ++index;
269 }
270 }
271 }
272#endif
273}
274
275/*---------------------------------------------------------------------------*/
276/*---------------------------------------------------------------------------*/
277
278namespace
279{
280NumArray<int, MDDim1> _createNumArray(Int32 size)
281{
282 std::cout << "IN_CREATE_1\n";
283 NumArray<int, MDDim1> a(size);
284 std::cout << "IN_CREATE_2\n";
285 for (Int32 i = 0; i < size; ++i)
286 a(i) = size + i + 2;
287 return a;
288}
289} // namespace
290TEST(NumArray3, Copy)
291{
292 int nb_x = 3;
293 int nb_y = 4;
294 int nb_z = 5;
295 NumArray<Real, MDDim3> v(nb_x, nb_y, nb_z);
296 v.fill(3.2);
297 NumArray<Real, MDDim3> v2(nb_x * 2, nb_y / 2, nb_z * 3);
298
299 v.copy(v2.mdspan());
300
301 {
302 NumArray<int, MDDim1> vi0(4, { 1, 3, 5, 7 });
303 NumArray<int, MDDim1> vi1(vi0);
304 NumArray<int, MDDim1> vi2;
305 vi2 = vi1;
306 ASSERT_EQ(vi1.to1DSpan(), vi0.to1DSpan());
307 ASSERT_EQ(vi2.to1DSpan(), vi1.to1DSpan());
308 NumArray<int, MDDim1> vi3(vi0.to1DSpan());
309 ASSERT_EQ(vi3.to1DSpan(), vi0.to1DSpan());
310
311 Span<const int> vi0_span(vi0.to1DSmallSpan());
312 Span<const int> vi1_span(vi1.to1DSmallSpan());
313 ASSERT_EQ(vi0.to1DSpan(), vi0_span);
314 ASSERT_EQ(vi1_span, vi1.to1DSpan());
315 ASSERT_EQ(vi1.to1DSmallSpan(), vi0.to1DSmallSpan());
316 ASSERT_EQ(vi1.to1DConstSmallSpan(), vi0.to1DConstSmallSpan());
317 const NumArray<int, MDDim1>& v1_ref = vi1;
318 Span<const int> vi1_ref_span(v1_ref.to1DSmallSpan());
319 ASSERT_EQ(vi1_ref_span, vi1.to1DSpan());
320 }
321
322 {
323 NumArray<int, MDDim1> vi0(4, { 1, 3, 5, 7 });
324 NumArray<int, MDDim1> vi1(vi0);
325 NumArray<int, MDDim1> vi2;
326 vi2 = vi1;
327 ASSERT_EQ(vi1.to1DSpan(), vi0.to1DSpan());
328 ASSERT_EQ(vi2.to1DSpan(), vi1.to1DSpan());
329 }
330}
331
332TEST(NumArray3, Move)
333{
334 // Test NumArray::NumArray(NumArray&&)
335 {
336 std::cout << "PART_1\n";
337 NumArray<Int32, MDDim1> test_move(5);
338 test_move.fill(3);
339 Int32 wanted_size1 = 23;
340 test_move = _createNumArray(wanted_size1);
341 std::cout << "PART_2\n";
342 ASSERT_EQ(test_move.totalNbElement(), wanted_size1) << "Taille incorrecte (test move 1)";
343 ASSERT_EQ(test_move[6], wanted_size1 + 8) << "Taille incorrecte (test move 2)";
344 Int32 wanted_size2 = 17;
345 test_move = _createNumArray(wanted_size2);
346 std::cout << "PART_3\n";
347 ASSERT_EQ(test_move.totalNbElement(), wanted_size2) << "Taille incorrecte (test move 3)";
348 ASSERT_EQ(test_move[3], wanted_size2 + 5) << "Taille incorrecte (test move 4)";
349 }
350 // Test NumArray::operator=(NumArray&&)
351 {
352 Int32 wanted_size1 = 31;
353 std::cout << "PART_4\n";
354 NumArray<Int32, MDDim1> test_move(_createNumArray(wanted_size1));
355 std::cout << "PART_5\n";
356 ASSERT_EQ(test_move.totalNbElement(), wanted_size1) << "Taille incorrecte (test move 1)";
357 ASSERT_EQ(test_move[7], wanted_size1 + 9) << "Taille incorrecte (test move 2)";
358 }
359}
360
361/*---------------------------------------------------------------------------*/
362/*---------------------------------------------------------------------------*/
363
364TEST(NumArray3, Index)
365{
366 ArrayIndex<3> index(1, 4, 2);
367 auto [i, j, k] = index();
368
369 ASSERT_TRUE(i == 1);
370 ASSERT_TRUE(j == 4);
371 ASSERT_TRUE(k == 2);
372}
373
374namespace
375{
376template <typename T>
377void _setNumArray2Values(T& a)
378{
379 for (Int32 i = 0; i < a.dim1Size(); ++i) {
380 for (Int32 j = 0; j < a.dim2Size(); ++j) {
381 a(i, j) = (i * 253) + j;
382 }
383 }
384}
385template <typename T>
386void _setNumArray3Values(T& a)
387{
388 for (Int32 i = 0; i < a.dim1Size(); ++i) {
389 for (Int32 j = 0; j < a.dim2Size(); ++j) {
390 for (Int32 k = 0; k < a.dim3Size(); ++k) {
391 a(i, j, k) = (i * 253) + (j * 27) + k;
392 }
393 }
394 }
395}
396} // namespace
397
398/*---------------------------------------------------------------------------*/
399/*---------------------------------------------------------------------------*/
400
401TEST(NumArray2, Layout)
402{
403 std::cout << "TEST_NUMARRAY2 Disposition\n";
404
405 {
406 NumArray<Real, MDDim2, RightLayout> a(3, 5);
407 ASSERT_EQ(a.totalNbElement(), (3 * 5));
408 _setNumArray2Values(a);
409 auto values = a.to1DSpan();
410 std::cout << "V=" << values << "\n";
411 UniqueArray<Real> ref_value = { 0, 1, 2, 3, 4, 253, 254, 255, 256, 257, 506, 507, 508, 509, 510 };
412 ASSERT_EQ(values.smallView(), ref_value.view());
413 }
414
415 {
416 NumArray<Real, MDDim2, LeftLayout2> a(3, 5);
417 ASSERT_EQ(a.totalNbElement(), (3 * 5));
418 _setNumArray2Values(a);
419 auto values = a.to1DSpan();
420 std::cout << "V=" << values << "\n";
421 UniqueArray<Real> ref_value = { 0, 253, 506, 1, 254, 507, 2, 255, 508, 3, 256, 509, 4, 257, 510 };
422 ASSERT_EQ(values.smallView(), ref_value.view());
423 }
424}
425
426/*---------------------------------------------------------------------------*/
427/*---------------------------------------------------------------------------*/
428
429template <typename NumArray3>
430void _checkRightLayoutDim3(NumArray3& a)
431{
432 // Le tableau doit avoir les dimensions (2,3,5);
433 ASSERT_EQ(a.totalNbElement(), (2 * 3 * 5));
434 ASSERT_EQ(a.extent0(), 2);
435 ASSERT_EQ(a.extent1(), 3);
436 ASSERT_EQ(a.extent2(), 5);
437 _setNumArray3Values(a);
438 auto values = a.to1DSpan();
439 std::cout << "V=" << values << "\n";
440 UniqueArray<Real> ref_value = {
441 0, 1, 2, 3, 4, 27, 28, 29, 30, 31, 54, 55, 56, 57, 58,
442 253, 254, 255, 256, 257, 280, 281, 282, 283, 284, 307, 308, 309, 310, 311
443 };
444 ASSERT_EQ(values.smallView(), ref_value.view());
445}
446
447template <typename NumArray3>
448void _checkLeftLayoutDim3(NumArray3& a)
449{
450 // Le tableau doit avoir les dimensions (2,3,5);
451 //NumArray<Real,MDDim3,LeftLayout3> a(2,3,5);
452 ASSERT_EQ(a.totalNbElement(), (2 * 3 * 5));
453 _setNumArray3Values(a);
454 auto values = a.to1DSpan();
455 std::cout << "V=" << values << "\n";
456 UniqueArray<Real> ref_value = {
457 0, 253, 27, 280, 54, 307, 1, 254, 28, 281, 55, 308, 2, 255, 29,
458 282, 56, 309, 3, 256, 30, 283, 57, 310, 4, 257, 31, 284, 58, 311
459 };
460 ASSERT_EQ(values.smallView(), ref_value.view());
461}
462
463TEST(NumArray3, Layout)
464{
465 std::cout << "TEST_NUMARRAY3 Disposition\n";
466
467 {
468 NumArray<Real, MDDim3, RightLayout3> a(2, 3, 5);
469 std::cout << "TEST_NUMARRAY3 RightLayout 1\n";
470 _checkRightLayoutDim3(a);
471 }
472 {
473 NumArray<Real, ExtentsV<Int32, DynExtent, 3, 5>, RightLayout3> a(2);
474 std::cout << "TEST_NUMARRAY3 RightLayout 2\n";
475 _checkRightLayoutDim3(a);
476 }
477 {
478 NumArray<Real, ExtentsV<Int32, 2, DynExtent, 5>, RightLayout3> a(3);
479 std::cout << "TEST_NUMARRAY3 RightLayout 3\n";
480 _checkRightLayoutDim3(a);
481 }
482 {
483 NumArray<Real, ExtentsV<Int32, 2, 3, 5>, RightLayout3> a;
484 std::cout << "TEST_NUMARRAY3 RightLayout 4\n";
485 _checkRightLayoutDim3(a);
486 }
487 {
488 NumArray<Real, ExtentsV<Int32, DynExtent, 3, DynExtent>, RightLayout3> a(2, 5);
489 std::cout << "TEST_NUMARRAY3 RightLayout 5\n";
490 _checkRightLayoutDim3(a);
491 }
492
493 {
494 NumArray<Real, MDDim3, LeftLayout3> a(2, 3, 5);
495 std::cout << "TEST_NUMARRAY3 LeftLayout 1\n";
496 _checkLeftLayoutDim3(a);
497 }
498 {
499 NumArray<Real, ExtentsV<Int32, DynExtent, 3, 5>, LeftLayout3> a(2);
500 std::cout << "TEST_NUMARRAY3 LeftLayout 2\n";
501 _checkLeftLayoutDim3(a);
502 }
503 {
504 NumArray<Real, ExtentsV<Int32, 2, DynExtent, 5>, LeftLayout3> a(3);
505 std::cout << "TEST_NUMARRAY3 LeftLayout 3\n";
506 _checkLeftLayoutDim3(a);
507 }
508 {
509 NumArray<Real, ExtentsV<Int32, 2, 3, 5>, LeftLayout3> a;
510 std::cout << "TEST_NUMARRAY3 LeftLayout 4\n";
511 _checkLeftLayoutDim3(a);
512 }
513 {
514 NumArray<Real, ExtentsV<Int32, DynExtent, 3, DynExtent>, LeftLayout3> a(2, 5);
515 std::cout << "TEST_NUMARRAY3 LeftLayout 5\n";
516 _checkLeftLayoutDim3(a);
517 }
518}
519
520/*---------------------------------------------------------------------------*/
521/*---------------------------------------------------------------------------*/
522
523TEST(NumArray, RealN)
524{
525 {
526 NumArray<Real2, MDDim1> a(5);
527 a(2) = Real2(0.0, 3.2);
528 a(3)(1) = 2.0;
529 ASSERT_EQ(a(3).y, 2.0);
530 }
531
532 {
533 NumArray<Real3, MDDim1> a(5);
534 const Real3 v(0.0, 3.2, 5.6);
535 a(0) = v;
536 a(4)(1) = 4.0;
537 ASSERT_EQ(a(4).y, 4.0);
538 ASSERT_EQ(a(0), v);
539 }
540
541 {
542 NumArray<Real2x2, MDDim1> a(5);
543 const Real2 v0(1.2, 1.7);
544 const Real2x2 v(Real2(3.2, 5.6), Real2(3.4, 1.7));
545 a(0) = v;
546 a(3)(1, 0) = v0.x;
547 a(3)(1, 1) = v0.y;
548 a(4)(1, 0) = 4.0;
549 ASSERT_EQ(a(4).y.x, 4.0);
550 ASSERT_EQ(a(0), v);
551 ASSERT_EQ(a(3)(1), v0);
552 }
553
554 {
555 NumArray<Real3x3, MDDim1> a(5);
556 const Real3 v0(1.2, 3.4, 1.7);
557 const Real3x3 v(Real3(0.0, 3.2, 5.6), Real3(1.2, 3.4, 1.7), Real3(9.2, 1.4, 5.0));
558 a(0) = v;
559 a(3)(1)(0) = v0.x;
560 a(3)(1)(1) = v0.y;
561 a(3)(1)(2) = v0.z;
562 a(4)(1)(2) = 4.0;
563 ASSERT_EQ(a(4).y.z, 4.0);
564 ASSERT_EQ(a(0), v);
565 ASSERT_EQ(a(3)(1), v0);
566 }
567}
568
569/*---------------------------------------------------------------------------*/
570/*---------------------------------------------------------------------------*/
571
572TEST(NumArray, ReadFromText)
573{
574 {
575 const char* values1_str = "1 3 -2 \n -7 -5 12 \n 3 9 11\n";
576 NumArray<Int32, MDDim1> ref_value(9, { 1, 3, -2, -7, -5, 12, 3, 9, 11 });
577 std::istringstream istr1(values1_str);
578 NumArray<Int32, MDDim1> int32_values;
579 NumArrayUtils::readFromText(int32_values, istr1);
580 ASSERT_EQ(int32_values.extent0(), 9);
581 ASSERT_EQ(int32_values.to1DSpan(), ref_value.to1DSpan());
582 }
583 {
584 const char* values1_str = "1.1 3.3 -2.5 \n \n 2.1 4.99 12.23 \n 23 \n 45.1 11.9e2 -12.6e4\n";
585 NumArray<Real, MDDim1> ref_value(10, { 1.1, 3.3, -2.5, 2.1, 4.99, 12.23, 23, 45.1, 11.9e2, -12.6e4 });
586 std::istringstream istr1(values1_str);
587 NumArray<Real, MDDim1> real_values;
588 NumArrayUtils::readFromText(real_values, istr1);
589 ASSERT_EQ(real_values.extent0(), 10);
590 ASSERT_EQ(real_values.to1DSpan(), ref_value.to1DSpan());
591 }
592}
593namespace TestCopyNumArray
594{
595using Real = double;
596
601
602auto bar()
603{
604 auto tpq = Arcane::NumArray<Real, Arcane::MDDim1>(5);
605 tpq.fill(1.526);
606 auto const& w = tpq;
607 std::cout << w.to1DSpan() << "\n";
608 B b{ w };
609 std::cout << b.a_.to1DSpan() << "\n";
610 return b;
611}
612
613auto bar2()
614{
615 auto tpq = Arcane::NumArray<Real, Arcane::MDDim1>(5);
616 tpq.fill(1.526);
617 std::cout << tpq.to1DSpan() << "\n";
618 return tpq;
619}
620
621} // namespace TestCopyNumArray
622
623TEST(NumArray, TestCopy)
624{
625 using namespace TestCopyNumArray;
626
627 auto test4 = bar();
628 std::cout << "Val 4 = "
629 << &test4.a_
630 << " " << test4.a_.to1DSpan() << "\n";
631 auto test5 = bar2();
632 std::cout << "Val 5 = " << &test5 << " " << test5.to1DSpan() << "\n";
633 ASSERT_EQ(test4.a_.to1DSpan(), test5.to1DSpan());
634}
635
636/*---------------------------------------------------------------------------*/
637/*---------------------------------------------------------------------------*/
638
639TEST(NumArray, SpanUsage)
640{
641 std::cout << "Test_SpanUsage";
642 UniqueArray<Int32> ua1 = { 0, 1, 2, 3, 4, 253, 254, 255, 256, 25 };
643 NumArray<Int32, MDDim1> a1;
644 SmallSpan<const Int32> const_span_ua1 = ua1.smallSpan();
645 SmallSpan<Int32> span_ua1 = ua1.smallSpan();
646 a1.copy(span_ua1);
647 ASSERT_EQ(span_ua1, a1.to1DSmallSpan());
648
649 a1.fill(3);
650 a1.copy(span_ua1, nullptr);
651 ASSERT_EQ(span_ua1, a1.to1DSmallSpan());
652
653 MDSpan<const Int32, MDDim1> md_a1(span_ua1);
654 ASSERT_EQ(span_ua1, md_a1.to1DSmallSpan());
655
656 MDSpan<const Int32, MDDim1> md_a2(const_span_ua1);
657 ASSERT_EQ(const_span_ua1, md_a2.to1DSmallSpan());
658
659 MDSpan<Int32, MDDim1> md_a3(span_ua1);
660 ASSERT_EQ(span_ua1, md_a3.to1DSmallSpan());
661
662 md_a3 = a1.to1DSmallSpan();
663 ASSERT_EQ(a1.to1DSmallSpan(), md_a3.to1DSmallSpan());
664}
665
666/*---------------------------------------------------------------------------*/
667/*---------------------------------------------------------------------------*/
668
669namespace Arcane
670{
671// On instantie explicitement pour tester que toutes les méthodes templates sont valides
672template class NumArray<float, MDDim4, RightLayout>;
673template class NumArray<float, MDDim3, RightLayout>;
674template class NumArray<float, MDDim2, RightLayout>;
675
676template class NumArray<float, MDDim4, LeftLayout>;
677template class NumArray<float, MDDim3, LeftLayout>;
678template class NumArray<float, MDDim2, LeftLayout>;
679
680template class NumArray<float, MDDim1>;
681
682template class NumArray<float, ExtentsV<Int32, 7, DynExtent, 2, 3>, RightLayout>;
683template class NumArray<float, ExtentsV<Int32, DynExtent, 2, 3>, RightLayout>;
684template class NumArray<float, ExtentsV<Int32, 2, 3>>;
685template class NumArray<float, ExtentsV<Int32, 2>>;
686template class NumArray<float, ExtentsV<Int32, 3, DynExtent>>;
687
688template class MDSpan<float, MDDim4, RightLayout>;
689template class MDSpan<float, MDDim3, RightLayout>;
690template class MDSpan<float, MDDim2, RightLayout>;
691
692template class MDSpan<float, MDDim4, LeftLayout>;
693template class MDSpan<float, MDDim3, LeftLayout>;
694template class MDSpan<float, MDDim2, LeftLayout>;
695
696template class MDSpan<float, MDDim1>;
697
698template class MDSpan<float, ExtentsV<Int32, 7, DynExtent, 2, 3>, RightLayout>;
699template class MDSpan<float, ExtentsV<Int32, DynExtent, 2, 3>, RightLayout>;
700template class MDSpan<float, ExtentsV<Int32, 2, 3>>;
701template class MDSpan<float, ExtentsV<Int32, 2>>;
702template class MDSpan<float, ExtentsV<Int32, 3, DynExtent>>;
703} // namespace Arcane
704
705/*---------------------------------------------------------------------------*/
706/*---------------------------------------------------------------------------*/
ASSERT_TRUE
#define ASSERT_TRUE(condition)
Vérifie que condition est vrai.
Definition Assertion.h:125
Arcane::Array::smallSpan
SmallSpan< const T > smallSpan() const
Vue immutable sur ce tableau.
Definition arccore/src/common/arccore/common/Array.h:158
Arcane::Array::view
ArrayView< T > view() const
Vue mutable sur ce tableau.
Definition arccore/src/common/arccore/common/Array.h:142
Arcane::MDSpan
Classe de base des vues multi-dimensionnelles.
Definition arccore/src/base/arccore/base/MDSpan.h:43
Arcane::MDSpan::extent1
constexpr ExtentIndexType extent1() const
Valeur de la deuxième dimension.
Definition arccore/src/base/arccore/base/MDSpan.h:167
Arcane::MDSpan::ptrAt
constexpr DataType * ptrAt(ExtentIndexType i, ExtentIndexType j, ExtentIndexType k, ExtentIndexType l) const
Pointeur sur la valeur pour l'élément i,j,k.
Definition arccore/src/base/arccore/base/MDSpan.h:248
Arcane::MDSpan::slice
__host__ __device__ MDSpan< DataType, RemovedFirstExtentsType, LayoutPolicy > slice(ExtentIndexType i) const
Retourne une vue de dimension (N-1) à partir de l'élément d'indice i.
Definition arccore/src/base/arccore/base/MDSpan.h:295
Arcane::MDSpan::extent0
constexpr ExtentIndexType extent0() const
Valeur de la première dimension.
Definition arccore/src/base/arccore/base/MDSpan.h:165
Arcane::NumArray
Tableaux multi-dimensionnels pour les types numériques accessibles sur accélérateurs.
Definition arccore/src/common/arccore/common/NumArray.h:57
Arcane::NumArray::to1DSpan
Span< const DataType > to1DSpan() const
Vue 1D constante sur l'instance.
Definition arccore/src/common/arccore/common/NumArray.h:627
Arcane::NumArray::extent2
constexpr ExtentIndexType extent2() const
Valeur de la troisième dimension.
Definition arccore/src/common/arccore/common/NumArray.h:295
Arcane::NumArray::extent1
constexpr ExtentIndexType extent1() const
Valeur de la deuxième dimension.
Definition arccore/src/common/arccore/common/NumArray.h:293
Arcane::NumArray::to1DSmallSpan
constexpr SmallSpan< DataType > to1DSmallSpan()
Vue 1D sur l'instance (uniquement si rank == 1).
Definition arccore/src/common/arccore/common/NumArray.h:643
Arcane::NumArray::copy
void copy(ConstMDSpanType rhs)
Copie dans l'instance les valeurs de rhs.
Definition arccore/src/common/arccore/common/NumArray.h:450
Arcane::NumArray::extent3
constexpr ExtentIndexType extent3() const
Valeur de la quatrième dimension.
Definition arccore/src/common/arccore/common/NumArray.h:297
Arcane::NumArray::fill
void fill(const DataType &v)
Remplit les valeurs du tableau par v.
Definition arccore/src/common/arccore/common/NumArray.h:382
Arcane::NumArray::resize
void resize(ExtentIndexType dim1_size)
Modifie la taille du tableau en gardant pas les valeurs actuelles.
Definition arccore/src/common/arccore/common/NumArray.h:302
Arcane::NumArray::extent0
constexpr ExtentIndexType extent0() const
Valeur de la première dimension.
Definition arccore/src/common/arccore/common/NumArray.h:291
Arcane::Real2
Classe gérant un vecteur réel 2-dimensionnel.
Definition arccore/src/base/arccore/base/Real2.h:122
Arcane::Real2x2
Classe gérant une matrice 2x2 de réels.
Definition arccore/src/base/arccore/base/Real2x2.h:55
Arcane::Real3
Classe gérant un vecteur réel de 3 dimensions.
Definition arccore/src/base/arccore/base/Real3.h:128
Arcane::Real3x3
Classe gérant une matrice réelle 3x3.
Definition arccore/src/base/arccore/base/Real3x3.h:67
Arcane::SmallSpan
Vue d'un tableau d'éléments de type T.
Definition Span.h:802
Arcane::Span
Vue d'un tableau d'éléments de type T.
Definition Span.h:633
Arcane::UniqueArray
Vecteur 1D de données avec sémantique par valeur (style STL).
Definition arccore/src/common/arccore/common/Array.h:888
Arcane::NumArrayUtils::readFromText
void readFromText(NumArray< double, MDDim1 > &v, std::istream &input)
Remplit v avec les valeurs de input.
Definition NumArrayUtils.cc:50
Arcane
-- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature --
Definition arcane/src/arcane/accelerator/AcceleratorGlobal.h:37