Arcane  4.1.12.0
Developer documentation
Loading...
Searching...
No Matches
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 Empty\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 Basic\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 Basic2\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 // Note, v.extents() changes if 'v' is resized
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 // NOTE: temporarily disables the test until the method
225 // resize() of 'NumArray' preserves values
226#if NUMARRAY_HAS_VALID_RESIZE
227 // The values below depend on the current implementation
228 // of NumArray::resize(). I am not sure it is valid to test them
229 std::vector<Int64> valid_values = {
230 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
231 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
232 24, 25, 26, 27, 28, 29, 20, 21, 22, 23, 24, 25
233 };
234 ASSERT_EQ(valid_values.size(), (size_t)36);
235
236 v_extents = v.extentsWithOffset();
237 Int64 index = 0;
238 for (Int64 x = 0, xn = v.dim1Size(); x < xn; ++x) {
239 for (Int64 y = 0, yn = v.dim2Size(); y < yn; ++y) {
240 for (Int64 z = 0, zn = v.dim3Size(); z < zn; ++z) {
241 ArrayBoundsIndex<3> idx{ x, y, z };
242 Int64 offset = v_extents.offset(idx);
243 Int64 val1 = v(x, y, z);
244 Int64 val2 = v({ x, y, z });
245 std::cout << "XYZ=" << x << " " << y << " " << z
246 << " V=" << val1 << " offset=" << offset << "\n";
247 ASSERT_EQ(index, offset);
248 ASSERT_EQ(val1, val2);
249 ASSERT_EQ(valid_values.at(offset), val1);
250 ++index;
251 }
252 }
253 }
254#endif
255}
256
257/*---------------------------------------------------------------------------*/
258/*---------------------------------------------------------------------------*/
259
260namespace
261{
262NumArray<int, MDDim1> _createNumArray(Int32 size)
263{
264 std::cout << "IN_CREATE_1\n";
265 NumArray<int, MDDim1> a(size);
266 std::cout << "IN_CREATE_2\n";
267 for (Int32 i = 0; i < size; ++i)
268 a(i) = size + i + 2;
269 return a;
270}
271} // namespace
272TEST(NumArray3, Copy)
273{
274 int nb_x = 3;
275 int nb_y = 4;
276 int nb_z = 5;
277 NumArray<Real, MDDim3> v(nb_x, nb_y, nb_z);
278 v.fill(3.2);
279 NumArray<Real, MDDim3> v2(nb_x * 2, nb_y / 2, nb_z * 3);
280
281 v.copy(v2.mdspan());
282
283 {
284 NumArray<int, MDDim1> vi0(4, { 1, 3, 5, 7 });
285 NumArray<int, MDDim1> vi1(vi0);
286 NumArray<int, MDDim1> vi2;
287 vi2 = vi1;
288 ASSERT_EQ(vi1.to1DSpan(), vi0.to1DSpan());
289 ASSERT_EQ(vi2.to1DSpan(), vi1.to1DSpan());
290 NumArray<int, MDDim1> vi3(vi0.to1DSpan());
291 ASSERT_EQ(vi3.to1DSpan(), vi0.to1DSpan());
292
293 Span<const int> vi0_span(vi0.to1DSmallSpan());
294 Span<const int> vi1_span(vi1.to1DSmallSpan());
295 ASSERT_EQ(vi0.to1DSpan(), vi0_span);
296 ASSERT_EQ(vi1_span, vi1.to1DSpan());
297 ASSERT_EQ(vi1.to1DSmallSpan(), vi0.to1DSmallSpan());
298 ASSERT_EQ(vi1.to1DConstSmallSpan(), vi0.to1DConstSmallSpan());
299 const NumArray<int, MDDim1>& v1_ref = vi1;
300 Span<const int> vi1_ref_span(v1_ref.to1DSmallSpan());
301 ASSERT_EQ(vi1_ref_span, vi1.to1DSpan());
302 }
303
304 {
305 NumArray<int, MDDim1> vi0(4, { 1, 3, 5, 7 });
306 NumArray<int, MDDim1> vi1(vi0);
307 NumArray<int, MDDim1> vi2;
308 vi2 = vi1;
309 ASSERT_EQ(vi1.to1DSpan(), vi0.to1DSpan());
310 ASSERT_EQ(vi2.to1DSpan(), vi1.to1DSpan());
311 }
312}
313
314TEST(NumArray3, Move)
315{
316 // Test NumArray::NumArray(NumArray&&)
317 {
318 std::cout << "PART_1\n";
319 NumArray<Int32, MDDim1> test_move(5);
320 test_move.fill(3);
321 Int32 wanted_size1 = 23;
322 test_move = _createNumArray(wanted_size1);
323 std::cout << "PART_2\n";
324 ASSERT_EQ(test_move.totalNbElement(), wanted_size1) << "Bad size (test move 1)";
325 ASSERT_EQ(test_move[6], wanted_size1 + 8) << "Bad size (test move 2)";
326 Int32 wanted_size2 = 17;
327 test_move = _createNumArray(wanted_size2);
328 std::cout << "PART_3\n";
329 ASSERT_EQ(test_move.totalNbElement(), wanted_size2) << "Bad size (test move 3)";
330 ASSERT_EQ(test_move[3], wanted_size2 + 5) << "Bad size (test move 4)";
331 }
332 // Test NumArray::operator=(NumArray&&)
333 {
334 Int32 wanted_size1 = 31;
335 std::cout << "PART_4\n";
336 NumArray<Int32, MDDim1> test_move(_createNumArray(wanted_size1));
337 std::cout << "PART_5\n";
338 ASSERT_EQ(test_move.totalNbElement(), wanted_size1) << "Bad size (test move 1)";
339 ASSERT_EQ(test_move[7], wanted_size1 + 9) << "Bad size (test move 2)";
340 }
341}
342
343/*---------------------------------------------------------------------------*/
344/*---------------------------------------------------------------------------*/
345
346TEST(NumArray3, Index)
347{
348 ArrayIndex<3> index(1, 4, 2);
349 auto [i, j, k] = index();
350
351 ASSERT_TRUE(i == 1);
352 ASSERT_TRUE(j == 4);
353 ASSERT_TRUE(k == 2);
354}
355
356namespace
357{
358template <typename T>
359void _setNumArray2Values(T& a)
360{
361 for (Int32 i = 0; i < a.dim1Size(); ++i) {
362 for (Int32 j = 0; j < a.dim2Size(); ++j) {
363 a(i, j) = (i * 253) + j;
364 }
365 }
366}
367template <typename T>
368void _setNumArray3Values(T& a)
369{
370 for (Int32 i = 0; i < a.dim1Size(); ++i) {
371 for (Int32 j = 0; j < a.dim2Size(); ++j) {
372 for (Int32 k = 0; k < a.dim3Size(); ++k) {
373 a(i, j, k) = (i * 253) + (j * 27) + k;
374 }
375 }
376 }
377}
378} // namespace
379
380/*---------------------------------------------------------------------------*/
381/*---------------------------------------------------------------------------*/
382
383TEST(NumArray2, Layout)
384{
385 std::cout << "TEST_NUMARRAY2 Layout\n";
386
387 {
388 NumArray<Real, MDDim2, RightLayout> a(3, 5);
389 ASSERT_EQ(a.totalNbElement(), (3 * 5));
390 _setNumArray2Values(a);
391 auto values = a.to1DSpan();
392 std::cout << "V=" << values << "\n";
393 UniqueArray<Real> ref_value = { 0, 1, 2, 3, 4, 253, 254, 255, 256, 257, 506, 507, 508, 509, 510 };
394 ASSERT_EQ(values.smallView(), ref_value.view());
395 }
396
397 {
398 NumArray<Real, MDDim2, LeftLayout2> a(3, 5);
399 ASSERT_EQ(a.totalNbElement(), (3 * 5));
400 _setNumArray2Values(a);
401 auto values = a.to1DSpan();
402 std::cout << "V=" << values << "\n";
403 UniqueArray<Real> ref_value = { 0, 253, 506, 1, 254, 507, 2, 255, 508, 3, 256, 509, 4, 257, 510 };
404 ASSERT_EQ(values.smallView(), ref_value.view());
405 }
406}
407
408/*---------------------------------------------------------------------------*/
409/*---------------------------------------------------------------------------*/
410
411template <typename NumArray3>
412void _checkRightLayoutDim3(NumArray3& a)
413{
414 // The array must have dimensions (2,3,5);
415 ASSERT_EQ(a.totalNbElement(), (2 * 3 * 5));
416 ASSERT_EQ(a.extent0(), 2);
417 ASSERT_EQ(a.extent1(), 3);
418 ASSERT_EQ(a.extent2(), 5);
419 _setNumArray3Values(a);
420 auto values = a.to1DSpan();
421 std::cout << "V=" << values << "\n";
422 UniqueArray<Real> ref_value = {
423 0, 1, 2, 3, 4, 27, 28, 29, 30, 31, 54, 55, 56, 57, 58,
424 253, 254, 255, 256, 257, 280, 281, 282, 283, 284, 307, 308, 309, 310, 311
425 };
426 ASSERT_EQ(values.smallView(), ref_value.view());
427}
428
429template <typename NumArray3>
430void _checkLeftLayoutDim3(NumArray3& a)
431{
432 // The array must have dimensions (2,3,5);
433 //NumArray<Real,MDDim3,LeftLayout3> a(2,3,5);
434 ASSERT_EQ(a.totalNbElement(), (2 * 3 * 5));
435 _setNumArray3Values(a);
436 auto values = a.to1DSpan();
437 std::cout << "V=" << values << "\n";
438 UniqueArray<Real> ref_value = {
439 0, 253, 27, 280, 54, 307, 1, 254, 28, 281, 55, 308, 2, 255, 29,
440 282, 56, 309, 3, 256, 30, 283, 57, 310, 4, 257, 31, 284, 58, 311
441 };
442 ASSERT_EQ(values.smallView(), ref_value.view());
443}
444
445TEST(NumArray3, Layout)
446{
447 std::cout << "TEST_NUMARRAY3 Layout\n";
448
449 {
450 NumArray<Real, MDDim3, RightLayout3> a(2, 3, 5);
451 std::cout << "TEST_NUMARRAY3 RightLayout 1\n";
452 _checkRightLayoutDim3(a);
453 }
454 {
455 NumArray<Real, ExtentsV<Int32, DynExtent, 3, 5>, RightLayout3> a(2);
456 std::cout << "TEST_NUMARRAY3 RightLayout 2\n";
457 _checkRightLayoutDim3(a);
458 }
459 {
460 NumArray<Real, ExtentsV<Int32, 2, DynExtent, 5>, RightLayout3> a(3);
461 std::cout << "TEST_NUMARRAY3 RightLayout 3\n";
462 _checkRightLayoutDim3(a);
463 }
464 {
465 NumArray<Real, ExtentsV<Int32, 2, 3, 5>, RightLayout3> a;
466 std::cout << "TEST_NUMARRAY3 RightLayout 4\n";
467 _checkRightLayoutDim3(a);
468 }
469 {
470 NumArray<Real, ExtentsV<Int32, DynExtent, 3, DynExtent>, RightLayout3> a(2, 5);
471 std::cout << "TEST_NUMARRAY3 RightLayout 5\n";
472 _checkRightLayoutDim3(a);
473 }
474
475 {
476 NumArray<Real, MDDim3, LeftLayout3> a(2, 3, 5);
477 std::cout << "TEST_NUMARRAY3 LeftLayout 1\n";
478 _checkLeftLayoutDim3(a);
479 }
480 {
481 NumArray<Real, ExtentsV<Int32, DynExtent, 3, 5>, LeftLayout3> a(2);
482 std::cout << "TEST_NUMARRAY3 LeftLayout 2\n";
483 _checkLeftLayoutDim3(a);
484 }
485 {
486 NumArray<Real, ExtentsV<Int32, 2, DynExtent, 5>, LeftLayout3> a(3);
487 std::cout << "TEST_NUMARRAY3 LeftLayout 3\n";
488 _checkLeftLayoutDim3(a);
489 }
490 {
491 NumArray<Real, ExtentsV<Int32, 2, 3, 5>, LeftLayout3> a;
492 std::cout << "TEST_NUMARRAY3 LeftLayout 4\n";
493 _checkLeftLayoutDim3(a);
494 }
495 {
496 NumArray<Real, ExtentsV<Int32, DynExtent, 3, DynExtent>, LeftLayout3> a(2, 5);
497 std::cout << "TEST_NUMARRAY3 LeftLayout 5\n";
498 _checkLeftLayoutDim3(a);
499 }
500}
501
502/*---------------------------------------------------------------------------*/
503/*---------------------------------------------------------------------------*/
504
505TEST(NumArray, RealN)
506{
507 {
508 NumArray<Real2, MDDim1> a(5);
509 a(2) = Real2(0.0, 3.2);
510 a(3)(1) = 2.0;
511 ASSERT_EQ(a(3).y, 2.0);
512 }
513
514 {
515 NumArray<Real3, MDDim1> a(5);
516 const Real3 v(0.0, 3.2, 5.6);
517 a(0) = v;
518 a(4)(1) = 4.0;
519 ASSERT_EQ(a(4).y, 4.0);
520 ASSERT_EQ(a(0), v);
521 }
522
523 {
524 NumArray<Real2x2, MDDim1> a(5);
525 const Real2 v0(1.2, 1.7);
526 const Real2x2 v(Real2(3.2, 5.6), Real2(3.4, 1.7));
527 a(0) = v;
528 a(3)(1, 0) = v0.x;
529 a(3)(1, 1) = v0.y;
530 a(4)(1, 0) = 4.0;
531 ASSERT_EQ(a(4).y.x, 4.0);
532 ASSERT_EQ(a(0), v);
533 ASSERT_EQ(a(3)(1), v0);
534 }
535
536 {
537 NumArray<Real3x3, MDDim1> a(5);
538 const Real3 v0(1.2, 3.4, 1.7);
539 const Real3x3 v(Real3(0.0, 3.2, 5.6), Real3(1.2, 3.4, 1.7), Real3(9.2, 1.4, 5.0));
540 a(0) = v;
541 a(3)(1)(0) = v0.x;
542 a(3)(1)(1) = v0.y;
543 a(3)(1)(2) = v0.z;
544 a(4)(1)(2) = 4.0;
545 ASSERT_EQ(a(4).y.z, 4.0);
546 ASSERT_EQ(a(0), v);
547 ASSERT_EQ(a(3)(1), v0);
548 }
549}
550
551/*---------------------------------------------------------------------------*/
552/*---------------------------------------------------------------------------*/
553
554TEST(NumArray, ReadFromText)
555{
556 {
557 const char* values1_str = "1 3 -2 \n -7 -5 12 \n 3 9 11\n";
558 NumArray<Int32, MDDim1> ref_value(9, { 1, 3, -2, -7, -5, 12, 3, 9, 11 });
559 std::istringstream istr1(values1_str);
560 NumArray<Int32, MDDim1> int32_values;
561 NumArrayUtils::readFromText(int32_values, istr1);
562 ASSERT_EQ(int32_values.extent0(), 9);
563 ASSERT_EQ(int32_values.to1DSpan(), ref_value.to1DSpan());
564 }
565 {
566 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";
567 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 });
568 std::istringstream istr1(values1_str);
569 NumArray<Real, MDDim1> real_values;
570 NumArrayUtils::readFromText(real_values, istr1);
571 ASSERT_EQ(real_values.extent0(), 10);
572 ASSERT_EQ(real_values.to1DSpan(), ref_value.to1DSpan());
573 }
574}
575namespace TestCopyNumArray
576{
577using Real = double;
578
583
584auto bar()
585{
586 auto tpq = Arcane::NumArray<Real, Arcane::MDDim1>(5);
587 tpq.fill(1.526);
588 auto const& w = tpq;
589 std::cout << w.to1DSpan() << "\n";
590 B b{ w };
591 std::cout << b.a_.to1DSpan() << "\n";
592 return b;
593}
594
595auto bar2()
596{
597 auto tpq = Arcane::NumArray<Real, Arcane::MDDim1>(5);
598 tpq.fill(1.526);
599 std::cout << tpq.to1DSpan() << "\n";
600 return tpq;
601}
602
603} // namespace TestCopyNumArray
604
605TEST(NumArray, TestCopy)
606{
607 using namespace TestCopyNumArray;
608
609 auto test4 = bar();
610 std::cout << "Val 4 = "
611 << &test4.a_
612 << " " << test4.a_.to1DSpan() << "\n";
613 auto test5 = bar2();
614 std::cout << "Val 5 = " << &test5 << " " << test5.to1DSpan() << "\n";
615 ASSERT_EQ(test4.a_.to1DSpan(), test5.to1DSpan());
616}
617
618/*---------------------------------------------------------------------------*/
619/*---------------------------------------------------------------------------*/
620
621TEST(NumArray, SpanUsage)
622{
623 std::cout << "Test_SpanUsage";
624 UniqueArray<Int32> ua1 = { 0, 1, 2, 3, 4, 253, 254, 255, 256, 25 };
625 NumArray<Int32, MDDim1> a1;
626 SmallSpan<const Int32> const_span_ua1 = ua1.smallSpan();
627 SmallSpan<Int32> span_ua1 = ua1.smallSpan();
628 a1.copy(span_ua1);
629 ASSERT_EQ(span_ua1, a1.to1DSmallSpan());
630
631 a1.fill(3);
632 a1.copy(span_ua1, nullptr);
633 ASSERT_EQ(span_ua1, a1.to1DSmallSpan());
634
635 MDSpan<const Int32, MDDim1> md_a1(span_ua1);
636 ASSERT_EQ(span_ua1, md_a1.to1DSmallSpan());
637
638 MDSpan<const Int32, MDDim1> md_a2(const_span_ua1);
639 ASSERT_EQ(const_span_ua1, md_a2.to1DSmallSpan());
640
641 MDSpan<Int32, MDDim1> md_a3(span_ua1);
642 ASSERT_EQ(span_ua1, md_a3.to1DSmallSpan());
643
644 md_a3 = a1.to1DSmallSpan();
645 ASSERT_EQ(a1.to1DSmallSpan(), md_a3.to1DSmallSpan());
646}
647
648/*---------------------------------------------------------------------------*/
649/*---------------------------------------------------------------------------*/
650
651namespace Arcane
652{
653// On instantie explicitement pour tester que toutes les méthodes templates sont valides
654template class NumArray<float, MDDim4, RightLayout>;
655template class NumArray<float, MDDim3, RightLayout>;
656template class NumArray<float, MDDim2, RightLayout>;
657
658template class NumArray<float, MDDim4, LeftLayout>;
659template class NumArray<float, MDDim3, LeftLayout>;
660template class NumArray<float, MDDim2, LeftLayout>;
661
662template class NumArray<float, MDDim1>;
663
664template class NumArray<float, ExtentsV<Int32, 7, DynExtent, 2, 3>, RightLayout>;
665template class NumArray<float, ExtentsV<Int32, DynExtent, 2, 3>, RightLayout>;
666template class NumArray<float, ExtentsV<Int32, 2, 3>>;
667template class NumArray<float, ExtentsV<Int32, 2>>;
668template class NumArray<float, ExtentsV<Int32, 3, DynExtent>>;
669
670template class MDSpan<float, MDDim4, RightLayout>;
671template class MDSpan<float, MDDim3, RightLayout>;
672template class MDSpan<float, MDDim2, RightLayout>;
673
674template class MDSpan<float, MDDim4, LeftLayout>;
675template class MDSpan<float, MDDim3, LeftLayout>;
676template class MDSpan<float, MDDim2, LeftLayout>;
677
678template class MDSpan<float, MDDim1>;
679
680template class MDSpan<float, ExtentsV<Int32, 7, DynExtent, 2, 3>, RightLayout>;
681template class MDSpan<float, ExtentsV<Int32, DynExtent, 2, 3>, RightLayout>;
682template class MDSpan<float, ExtentsV<Int32, 2, 3>>;
683template class MDSpan<float, ExtentsV<Int32, 2>>;
684template class MDSpan<float, ExtentsV<Int32, 3, DynExtent>>;
685} // namespace Arcane
686
687/*---------------------------------------------------------------------------*/
688/*---------------------------------------------------------------------------*/
ASSERT_TRUE
#define ASSERT_TRUE(condition)
Checks that condition is true.
Definition Assertion.h:128
Arcane::Array::smallSpan
SmallSpan< const T > smallSpan() const
Immutable view of this array.
Definition arccore/src/common/arccore/common/Array.h:159
Arcane::Array::view
ArrayView< T > view() const
Mutable view of this array.
Definition arccore/src/common/arccore/common/Array.h:143
Arcane::MDSpan
Base class for multi-dimensional views.
Definition arccore/src/base/arccore/base/MDSpan.h:44
Arcane::MDSpan::slice
__host__ __device__ MDSpan< DataType, RemovedFirstExtentsType, LayoutPolicy > slice(Int32 i) const
Returns a dimension (N-1) view starting from index element i.
Definition arccore/src/base/arccore/base/MDSpan.h:228
Arcane::MDSpan::ptrAt
constexpr __host__ __device__ DataType * ptrAt(Int32 i, Int32 j, Int32 k, Int32 l) const
Pointer to the value for element i,j,k,l.
Definition arccore/src/base/arccore/base/MDSpan.h:190
Arcane::MDSpan::extent1
constexpr __host__ __device__ Int32 extent1() const
Value of the second dimension.
Definition arccore/src/base/arccore/base/MDSpan.h:127
Arcane::MDSpan::extent0
constexpr __host__ __device__ Int32 extent0() const
Value of the first dimension.
Definition arccore/src/base/arccore/base/MDSpan.h:125
Arcane::NumArray
Multi-dimensional arrays for numerical types accessible on accelerators.
Definition arccore/src/common/arccore/common/NumArray.h:58
Arcane::NumArray::extent0
constexpr Int32 extent0() const
Value of the first dimension.
Definition arccore/src/common/arccore/common/NumArray.h:291
Arcane::NumArray::to1DSpan
Span< const DataType > to1DSpan() const
Constant 1D view on the instance.
Definition arccore/src/common/arccore/common/NumArray.h:679
Arcane::NumArray::copy
void copy(SmallSpan< const DataType > rhs)
Copies the values from rhs into the instance.
Definition arccore/src/common/arccore/common/NumArray.h:456
Arcane::NumArray::to1DSmallSpan
constexpr SmallSpan< DataType > to1DSmallSpan()
1D view on the instance (only if rank == 1)
Definition arccore/src/common/arccore/common/NumArray.h:695
Arcane::NumArray::fill
void fill(const DataType &v)
Fills the array values with v.
Definition arccore/src/common/arccore/common/NumArray.h:382
Arcane::NumArray::extent1
constexpr Int32 extent1() const
Value of the second dimension.
Definition arccore/src/common/arccore/common/NumArray.h:293
Arcane::NumArray::extent3
constexpr Int32 extent3() const
Value of the fourth dimension.
Definition arccore/src/common/arccore/common/NumArray.h:297
Arcane::NumArray::extent2
constexpr Int32 extent2() const
Value of the third dimension.
Definition arccore/src/common/arccore/common/NumArray.h:295
Arcane::NumArray::resize
void resize(Int32 dim1_size)
Resizes the array without keeping current values.
Definition arccore/src/common/arccore/common/NumArray.h:302
Arcane::Real2
Class managing a 2-dimensional real vector.
Definition Real2.h:122
Arcane::Real2x2
Class managing a 2x2 matrix of reals.
Definition Real2x2.h:55
Arcane::Real3
Class managing a 3-dimensional real vector.
Definition Real3.h:132
Arcane::Real3x3
Class managing a 3x3 real matrix.
Definition Real3x3.h:67
Arcane::SmallSpan
View of an array of elements of type T.
Definition Span.h:805
Arcane::Span
View of an array of elements of type T.
Definition Span.h:635
Arcane::UniqueArray
1D data vector with value semantics (STL style).
Definition arccore/src/common/arccore/common/Array.h:890
Arcane::NumArrayUtils::readFromText
void readFromText(NumArray< double, MDDim1 > &v, std::istream &input)
Fills v with the values from input.
Definition NumArrayUtils.cc:51
Arcane
-- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature --
Definition arcane/src/arcane/accelerator/AcceleratorGlobal.h:37