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