Arcane  v3.16.0.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
utils/NumArray.h
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2025 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/* NumArray.h (C) 2000-2025 */
9/* */
10/* Tableaux multi-dimensionnel pour les types numériques. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_UTILS_NUMARRAY_H
13#define ARCANE_UTILS_NUMARRAY_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arcane/utils/MDSpan.h"
18#include "arcane/utils/MDDim.h"
19#include "arcane/utils/NumArrayContainer.h"
20#include "arcane/utils/ArcaneCxx20.h"
21#include "arcane/utils/String.h"
22
23/*---------------------------------------------------------------------------*/
24/*---------------------------------------------------------------------------*/
25
26namespace Arcane
27{
28
29/*---------------------------------------------------------------------------*/
30/*---------------------------------------------------------------------------*/
31
32template <typename T>
33concept NumArrayDataTypeConcept = std::is_trivially_copyable_v<T>;
34
35/*---------------------------------------------------------------------------*/
36/*---------------------------------------------------------------------------*/
55template <typename DataType, typename Extents, typename LayoutPolicy>
58{
59 public:
60
61#if !defined(ARCANE_NO_CONCEPT_FOR_NUMARRAY)
62 static_assert(NumArrayDataTypeConcept<DataType>, "concept 'NumArrayDataTypeConcept' is not fullfilled");
63#endif
64
65 public:
66
67 using ExtentsType = Extents;
69 using DynamicDimsType = typename ExtentsType::DynamicDimsType;
72 using ArrayWrapper = impl::NumArrayContainer<DataType>;
73 using ArrayBoundsIndexType = typename MDSpanType::ArrayBoundsIndexType;
74 using value_type = DataType;
75 using LayoutPolicyType = LayoutPolicy;
76
77 using ConstSpanType ARCANE_DEPRECATED_REASON("Use 'ConstMDSpanType' instead") = ConstMDSpanType;
78 using SpanType ARCANE_DEPRECATED_REASON("Use 'MDSpanType' instead") = MDSpanType;
79
80 public:
81
83 static constexpr int rank() { return Extents::rank(); }
84
85 public:
86
89 {
91 }
92
94 explicit NumArray(DynamicDimsType extents)
95 {
97 }
98
100 NumArray(const DynamicDimsType& extents, eMemoryRessource r)
101 : m_data(r)
102 {
104 }
105
107 : m_data(r)
108 {
109 _resizeInit();
110 }
111
113 NumArray(Int32 dim1_size, Int32 dim2_size,
114 Int32 dim3_size, Int32 dim4_size) requires(Extents::nb_dynamic == 4)
115 : ThatClass(DynamicDimsType(dim1_size, dim2_size, dim3_size, dim4_size))
116 {
117 }
118
120 NumArray(Int32 dim1_size, Int32 dim2_size,
121 Int32 dim3_size, Int32 dim4_size, eMemoryRessource r) requires(Extents::nb_dynamic == 4)
122 : ThatClass(DynamicDimsType(dim1_size, dim2_size, dim3_size, dim4_size), r)
123 {
124 }
125
127 NumArray(Int32 dim1_size, Int32 dim2_size, Int32 dim3_size) requires(Extents::nb_dynamic == 3)
128 : ThatClass(DynamicDimsType(dim1_size, dim2_size, dim3_size))
129 {
130 }
131
132 NumArray(Int32 dim1_size, Int32 dim2_size, Int32 dim3_size, eMemoryRessource r) requires(Extents::nb_dynamic == 3)
133 : ThatClass(DynamicDimsType(dim1_size, dim2_size, dim3_size), r)
134 {
135 }
136
138 NumArray(Int32 dim1_size, Int32 dim2_size) requires(Extents::nb_dynamic == 2)
139 : ThatClass(DynamicDimsType(dim1_size, dim2_size))
140 {
141 }
142
143 NumArray(Int32 dim1_size, Int32 dim2_size, eMemoryRessource r) requires(Extents::nb_dynamic == 2)
144 : ThatClass(DynamicDimsType(dim1_size, dim2_size), r)
145 {
146 }
147
149 explicit NumArray(Int32 dim1_size) requires(Extents::nb_dynamic == 1)
150 : ThatClass(DynamicDimsType(dim1_size))
151 {
152 }
153
154 NumArray(Int32 dim1_size, eMemoryRessource r) requires(Extents::nb_dynamic == 1)
155 : ThatClass(DynamicDimsType(dim1_size), r)
156 {
157 }
158
165 NumArray(Int32 dim1_size, Int32 dim2_size, std::initializer_list<DataType> alist)
166 requires(Extents::is_full_dynamic() && Extents::rank() == 2)
167 : NumArray(dim1_size, dim2_size)
168 {
169 this->m_data.copyInitializerList(alist);
170 }
171
173 NumArray(Int32 dim1_size, std::initializer_list<DataType> alist)
174 requires(Extents::isDynamic1D())
175 : NumArray(dim1_size)
176 {
177 this->m_data.copyInitializerList(alist);
178 }
179
182 requires(Extents::isDynamic1D())
183 : NumArray(v.size())
184 {
185 this->m_data.copy(v);
186 }
187
190 requires(Extents::isDynamic1D())
191 : NumArray(arcaneCheckArraySize(v.size()))
192 {
193 this->m_data.copy(v);
194 }
195
196 NumArray(const ThatClass& rhs)
197 : m_span(rhs.m_span)
198 , m_data(rhs.m_data)
199 , m_total_nb_element(rhs.m_total_nb_element)
200 {
201 _updateSpanPointerFromData();
202 }
203
204 NumArray(ThatClass&& rhs)
205 : m_span(rhs.m_span)
206 , m_data(std::move(rhs.m_data))
207 , m_total_nb_element(rhs.m_total_nb_element)
208 {
209 }
210
211 ThatClass& operator=(ThatClass&&) = default;
212
220 ThatClass& operator=(const ThatClass& rhs)
221 {
222 if (&rhs == this)
223 return (*this);
224 eMemoryRessource r = memoryRessource();
225 eMemoryRessource rhs_r = rhs.memoryRessource();
226 if (rhs_r != r)
227 m_data = ArrayWrapper(rhs_r);
228 this->copy(rhs);
229 return (*this);
230 }
231
239 void swap(ThatClass& rhs)
240 {
241 m_data.swap(rhs.m_data);
242 std::swap(m_span, rhs.m_span);
243 std::swap(m_total_nb_element, rhs.m_total_nb_element);
244 }
245
246 public:
247
249 constexpr Int64 totalNbElement() const { return m_total_nb_element; }
251 static constexpr Int32 nbDimension() { return Extents::rank(); }
253 ArrayExtents<Extents> extents() const { return m_span.extents(); }
254 ArrayExtentsWithOffset<Extents, LayoutPolicy> extentsWithOffset() const
255 {
256 return m_span.extentsWithOffset();
257 }
258 Int64 capacity() const { return m_data.capacity(); }
259 eMemoryRessource memoryRessource() const { return m_data.memoryRessource(); }
264
266 IMemoryAllocator* memoryAllocator() const { return m_data.allocator(); }
267
273 void setDebugName(const String& str) { m_data.setDebugName(str); }
274
276 String debugName() { return m_data.debugName(); }
277
278 public:
279
281 constexpr Int32 dim1Size() const requires(Extents::rank() >= 1) { return m_span.extent0(); }
283 constexpr Int32 dim2Size() const requires(Extents::rank() >= 2) { return m_span.extent1(); }
285 constexpr Int32 dim3Size() const requires(Extents::rank() >= 3) { return m_span.extent2(); }
287 constexpr Int32 dim4Size() const requires(Extents::rank() >= 4) { return m_span.extent3(); }
288
290 constexpr Int32 extent0() const requires(Extents::rank() >= 1) { return m_span.extent0(); }
292 constexpr Int32 extent1() const requires(Extents::rank() >= 2) { return m_span.extent1(); }
294 constexpr Int32 extent2() const requires(Extents::rank() >= 3) { return m_span.extent2(); }
296 constexpr Int32 extent3() const requires(Extents::rank() >= 4) { return m_span.extent3(); }
297
298 public:
299
301 void resize(Int32 dim1_size) requires(Extents::nb_dynamic == 1)
302 {
303 m_span.m_extents = DynamicDimsType(dim1_size);
304 _resize();
305 }
306
307 // TODO: Rendre obsolète (juin 2025)
309 void resize(Int32 dim1_size, Int32 dim2_size, Int32 dim3_size, Int32 dim4_size) requires(Extents::nb_dynamic == 4)
310 {
311 this->resizeDestructive(DynamicDimsType(dim1_size, dim2_size, dim3_size, dim4_size));
312 }
313
314 // TODO: Rendre obsolète (juin 2025)
316 void resize(Int32 dim1_size, Int32 dim2_size, Int32 dim3_size) requires(Extents::nb_dynamic == 3)
317 {
318 this->resizeDestructive(DynamicDimsType(dim1_size, dim2_size, dim3_size));
319 }
320
321 // TODO: Rendre obsolète (juin 2025)
323 void resize(Int32 dim1_size, Int32 dim2_size) requires(Extents::nb_dynamic == 2)
324 {
325 this->resizeDestructive(DynamicDimsType(dim1_size, dim2_size));
326 }
327
334
335 void resizeDestructive(Int32 dim1_size, Int32 dim2_size, Int32 dim3_size, Int32 dim4_size) requires(Extents::nb_dynamic == 4)
336 {
337 this->resizeDestructive(DynamicDimsType(dim1_size, dim2_size, dim3_size, dim4_size));
338 }
339
341 void resizeDestructive(Int32 dim1_size, Int32 dim2_size, Int32 dim3_size) requires(Extents::nb_dynamic == 3)
342 {
343 this->resizeDestructive(DynamicDimsType(dim1_size, dim2_size, dim3_size));
344 }
345
347 void resizeDestructive(Int32 dim1_size, Int32 dim2_size) requires(Extents::nb_dynamic == 2)
348 {
349 this->resizeDestructive(DynamicDimsType(dim1_size, dim2_size));
350 }
351
353 void resizeDestructive(Int32 dim1_size) requires(Extents::nb_dynamic == 1)
354 {
355 this->resizeDestructive(DynamicDimsType(dim1_size));
356 }
357
358 // TODO: Rendre obsolète (juin 2025)
360 void resize(const DynamicDimsType& dims)
361 {
362 resizeDestructive(dims);
363 }
364
366 void resizeDestructive(const DynamicDimsType& dims)
367 {
368 m_span.m_extents = dims;
369 _resize();
370 }
371
372
373 public:
374
381 void fill(const DataType& v)
382 {
383 fillHost(v);
384 }
385
393 void fill(const DataType& v, SmallSpan<const Int32> indexes, const RunQueue* queue)
394 {
395 m_data.fill(v, indexes, queue);
396 }
397
404 void fill(const DataType& v, SmallSpan<const Int32> indexes, const RunQueue& queue)
405 {
406 m_data.fill(v, indexes, &queue);
407 }
408
414 void fill(const DataType& v, const RunQueue* queue)
415 {
416 m_data.fill(v, queue);
417 }
418
424 void fill(const DataType& v, const RunQueue& queue)
425 {
426 m_data.fill(v, &queue);
427 }
428
435 void fillHost(const DataType& v)
436 {
437 _checkHost(memoryRessource());
438 m_data.fill(v);
439 }
440
441 public:
442
449 void copy(SmallSpan<const DataType> rhs) requires(Extents::isDynamic1D())
450 {
451 copy(rhs, nullptr);
452 }
453
460 void copy(ConstMDSpanType rhs) { copy(rhs, nullptr); }
461
468 void copy(const ThatClass& rhs) { copy(rhs, nullptr); }
469
478 void copy(SmallSpan<const DataType> rhs, const RunQueue* queue) requires(Extents::isDynamic1D())
479 {
480 _resizeAndCopy(ConstMDSpanType(rhs), eMemoryRessource::Unknown, queue);
481 }
482
491 void copy(ConstMDSpanType rhs, const RunQueue* queue)
492 {
493 _resizeAndCopy(rhs, eMemoryRessource::Unknown, queue);
494 }
495
504 void copy(SmallSpan<const DataType> rhs, const RunQueue& queue) requires(Extents::isDynamic1D())
505 {
506 _resizeAndCopy(ConstMDSpanType(rhs), eMemoryRessource::Unknown, &queue);
507 }
508
517 void copy(ConstMDSpanType rhs, const RunQueue& queue)
518 {
519 _resizeAndCopy(rhs, eMemoryRessource::Unknown, &queue);
520 }
521
530 void copy(const ThatClass& rhs, const RunQueue* queue)
531 {
532 _resizeAndCopy(rhs.constMDSpan(), rhs.memoryRessource(), queue);
533 }
534
543 void copy(const ThatClass& rhs, const RunQueue& queue)
544 {
545 _resizeAndCopy(rhs.constMDSpan(), rhs.memoryRessource(), &queue);
546 }
547
548 public:
549
551 DataType& operator[](Int32 i) requires(Extents::rank() == 1) { return m_span(i); }
553 DataType operator[](Int32 i) const requires(Extents::rank() == 1) { return m_span(i); }
554
555 public:
556
558 DataType operator()(Int32 i, Int32 j, Int32 k, Int32 l) const requires(Extents::rank() == 4)
559 {
560 return m_span(i, j, k, l);
561 }
562
563 DataType& operator()(Int32 i, Int32 j, Int32 k, Int32 l) requires(Extents::rank() == 4)
564 {
565 return m_span(i, j, k, l);
566 }
567
569 DataType operator()(Int32 i, Int32 j, Int32 k) const requires(Extents::rank() == 3)
570 {
571 return m_span(i, j, k);
572 }
573
574 DataType& operator()(Int32 i, Int32 j, Int32 k) requires(Extents::rank() == 3)
575 {
576 return m_span(i, j, k);
577 }
578
580 DataType operator()(Int32 i, Int32 j) const requires(Extents::rank() == 2)
581 {
582 return m_span(i, j);
583 }
584
585 DataType& operator()(Int32 i, Int32 j) requires(Extents::rank() == 2)
586 {
587 return m_span(i, j);
588 }
589
590 DataType operator()(Int32 i) const requires(Extents::rank() == 1) { return m_span(i); }
592 DataType& operator()(Int32 i) requires(Extents::rank() == 1) { return m_span(i); }
593
594 public:
595
597 const DataType& operator()(ArrayBoundsIndexType idx) const
598 {
599 return m_span(idx);
600 }
601
602 DataType& operator()(ArrayBoundsIndexType idx)
603 {
604 return m_span(idx);
605 }
606
607 public:
608
609 // TODO: rendre obsolète
611 ARCANE_DEPRECATED_REASON("Y2023: Use operator() instead")
612 DataType& s(Int32 i, Int32 j, Int32 k, Int32 l) requires(Extents::rank() == 4)
613 {
614 return m_span(i, j, k, l);
615 }
616
617 ARCANE_DEPRECATED_REASON("Y2023: Use operator() instead")
618 DataType& s(Int32 i, Int32 j, Int32 k) requires(Extents::rank() == 3)
619 {
620 return m_span(i, j, k);
621 }
622
623 ARCANE_DEPRECATED_REASON("Y2023: Use operator() instead")
624 DataType& s(Int32 i, Int32 j) requires(Extents::rank() == 2)
625 {
626 return m_span(i, j);
627 }
628
629 ARCANE_DEPRECATED_REASON("Y2023: Use operator() instead")
630 DataType& s(Int32 i) requires(Extents::rank() == 1) { return m_span(i); }
631
633 ARCANE_DEPRECATED_REASON("Y2023: Use operator() instead")
634 DataType& s(ArrayBoundsIndexType idx)
635 {
636 return m_span(idx);
637 }
638
639 public:
640
642 ARCANE_DEPRECATED_REASON("Y2024: Use mdspan() instead")
643 MDSpanType span() { return m_span; }
644
646 ARCANE_DEPRECATED_REASON("Y2024: Use mdspan() instead")
647 ConstMDSpanType span() const { return m_span.constMDSpan(); }
648
650 ARCANE_DEPRECATED_REASON("Y2024: Use constMDSpan() instead")
651 ConstMDSpanType constSpan() const { return m_span.constMDSpan(); }
652
654 MDSpanType mdspan() { return m_span; }
655
657 ConstMDSpanType mdspan() const { return m_span.constMDSpan(); }
658
660 ConstMDSpanType constMDSpan() const { return m_span.constMDSpan(); }
661
663 Span<const DataType> to1DSpan() const { return m_span.to1DSpan(); }
664
666 Span<DataType> to1DSpan() { return m_span.to1DSpan(); }
667
669 constexpr operator MDSpanType() { return this->mdspan(); }
671 constexpr operator ConstMDSpanType() const { return this->constMDSpan(); }
672
674 constexpr operator SmallSpan<DataType>() requires(Extents::rank() == 1) { return this->to1DSpan().smallView(); }
676 constexpr operator SmallSpan<const DataType>() const requires(Extents::rank() == 1) { return this->to1DSpan().constSmallView(); }
677
679 constexpr SmallSpan<DataType> to1DSmallSpan() requires(Extents::rank() == 1) { return m_span.to1DSmallSpan(); }
681 constexpr SmallSpan<const DataType> to1DSmallSpan() const requires(Extents::rank() == 1) { return m_span.to1DSmallSpan(); }
683 constexpr SmallSpan<const DataType> to1DConstSmallSpan() const requires(Extents::rank() == 1) { return m_span.to1DConstSmallSpan(); }
684
685 public:
686
688 DataType* _internalData() { return m_span._internalData(); }
689
690 private:
691
692 MDSpanType m_span;
693 ArrayWrapper m_data;
694 Int64 m_total_nb_element = 0;
695
696 private:
697
698 void _updateSpanPointerFromData()
699 {
700 m_span.m_ptr = m_data.to1DSpan().data();
701 }
702
703 void _resizeAndCopy(ConstMDSpanType rhs, eMemoryRessource input_ressource, const RunQueue* queue)
704 {
705 this->resize(rhs.extents().dynamicExtents());
706 m_data.copyOnly(rhs.to1DSpan(), input_ressource, queue);
707 _updateSpanPointerFromData();
708 }
709
711 void _resize()
712 {
713 m_total_nb_element = m_span.extents().totalNbElement();
714 m_data.resize(m_total_nb_element);
715 _updateSpanPointerFromData();
716 }
717
726 {
727 if constexpr (ExtentsType::nb_dynamic == 0) {
728 resize(DynamicDimsType());
729 }
730 }
731};
732
733/*---------------------------------------------------------------------------*/
734/*---------------------------------------------------------------------------*/
735
736} // End namespace Arcane
737
738/*---------------------------------------------------------------------------*/
739/*---------------------------------------------------------------------------*/
740
741#endif
Integer capacity() const
Capacité (nombre d'éléments alloués) du vecteur.
NumArray()
Construit un tableau vide.
File d'exécution pour un accélérateur.
Classe de base des vues multi-dimensionnelles.
Definition MDSpan.h:44
void resizeDestructive(Int32 dim1_size, Int32 dim2_size, Int32 dim3_size, Int32 dim4_size)
Modifie la taille du tableau.
DataType operator()(Int32 i) const
Valeur pour l'élément i.
void resizeDestructive(Int32 dim1_size, Int32 dim2_size)
Modifie la taille du tableau en ne gardant pas les valeurs actuelles.
void copy(const ThatClass &rhs, const RunQueue *queue)
Copie dans l'instance les valeurs de rhs via la file queue.
constexpr Int32 extent0() const
Valeur de la première dimension.
Span< const DataType > to1DSpan() const
Vue 1D constante sur l'instance.
Span< std::byte > bytes()
Vue sous forme d'octets.
DataType & s(Int32 i, Int32 j, Int32 k, Int32 l)
DataType & operator()(Int32 i, Int32 j)
Positionne la valeur pour l'élément i,j.
constexpr SmallSpan< const DataType > to1DConstSmallSpan() const
Vue constante 1D sur l'instance (uniquement si rank == 1)
constexpr Int32 dim4Size() const
Valeur de la quatrième dimension.
DataType & operator()(Int32 i)
Positionne la valeur pour l'élément i.
NumArray(Int32 dim1_size, Int32 dim2_size, Int32 dim3_size)
Construit un tableau avec 3 valeurs dynamiques.
void swap(ThatClass &rhs)
Échange les données avec rhs.
void copy(const ThatClass &rhs)
Copie dans l'instance les valeurs de rhs.
Span< DataType > to1DSpan()
Vue 1D sur l'instance.
static constexpr int rank()
Nombre de dimensions du tableau.
DataType * _internalData()
DataType operator()(Int32 i, Int32 j) const
Valeur pour l'élément i,j.
NumArray(Int32 dim1_size, Int32 dim2_size)
Construit un tableau avec 2 valeurs dynamiques.
void fill(const DataType &v, const RunQueue *queue)
Remplit les éléments de l'instance la valeur v en utilisant la file queue.
void copy(SmallSpan< const DataType > rhs)
Copie dans l'instance les valeurs de rhs.
constexpr Int32 dim3Size() const
Valeur de la troisième dimension.
NumArray(eMemoryRessource r)
Créé un tableau vide utilisant la ressource mémoire r.
MDSpanType mdspan()
Vue multi-dimension sur l'instance.
constexpr SmallSpan< DataType > to1DSmallSpan()
Vue 1D sur l'instance (uniquement si rank == 1)
ThatClass & operator=(const ThatClass &rhs)
Opérateur de recopie.
DataType operator()(Int32 i, Int32 j, Int32 k) const
Valeur pour l'élément i,j,k.
DataType & operator()(Int32 i, Int32 j, Int32 k)
Positionne la valeur pour l'élément i,j,k.
NumArray(Int32 dim1_size, std::initializer_list< DataType > alist)
Construit un tableau à partir de valeurs prédéfinies (uniquement tableaux 1D dynamiques)
DataType & operator[](Int32 i)
Récupère une référence pour l'élément i.
void copy(ConstMDSpanType rhs)
Copie dans l'instance les valeurs de rhs.
void _resize()
Redimensionne le tableau à partir des valeurs de m_span.extents()
void resizeDestructive(Int32 dim1_size, Int32 dim2_size, Int32 dim3_size)
Modifie la taille du tableau en ne gardant pas les valeurs actuelles.
void fill(const DataType &v, const RunQueue &queue)
Remplit les éléments de l'instance la valeur v en utilisant la file queue.
String debugName()
Nom de debug (nul si aucun nom spécifié)
Span< const std::byte > bytes() const
Vue constante forme d'octets.
IMemoryAllocator * memoryAllocator() const
Allocateur mémoire associé
DataType & operator()(ArrayBoundsIndexType idx)
Référence modifiable l'élément idx.
void copy(ConstMDSpanType rhs, const RunQueue &queue)
Copie dans l'instance les valeurs de rhs via la file queue.
ConstMDSpanType mdspan() const
Vue constante multi-dimension sur l'instance.
NumArray(Int32 dim1_size, eMemoryRessource r)
Construit un tableau avec 1 valeur dynamique.
constexpr SmallSpan< const DataType > to1DSmallSpan() const
Vue constante 1D sur l'instance (uniquement si rank == 1)
const DataType & operator()(ArrayBoundsIndexType idx) const
Référence constante pour l'élément idx.
NumArray(Int32 dim1_size, Int32 dim2_size, Int32 dim3_size, Int32 dim4_size)
Construit un tableau avec 4 valeurs dynamiques.
void fill(const DataType &v, SmallSpan< const Int32 > indexes, const RunQueue *queue)
Remplit via la file queue, les valeurs du tableau d'indices données par indexes par la valeur v .
void copy(SmallSpan< const DataType > rhs, const RunQueue &queue)
Copie dans l'instance les valeurs de rhs via la file queue.
void copy(ConstMDSpanType rhs, const RunQueue *queue)
Copie dans l'instance les valeurs de rhs via la file queue.
void resize(const DynamicDimsType &dims)
Modifie la taille du tableau en ne gardant pas les valeurs actuelles.
NumArray(Int32 dim1_size, Int32 dim2_size, eMemoryRessource r)
Construit un tableau avec 2 valeurs dynamiques.
void fill(const DataType &v)
Remplit les valeurs du tableau par v.
void fillHost(const DataType &v)
Remplit les valeurs du tableau par v.
constexpr Int32 extent1() const
Valeur de la deuxième dimension.
void resize(Int32 dim1_size, Int32 dim2_size)
Modifie la taille du tableau en ne gardant pas les valeurs actuelles.
static constexpr Int32 nbDimension()
Nombre de dimensions.
void _resizeInit()
Allocation éventuelle lors de l'initialisation.
void resizeDestructive(const DynamicDimsType &dims)
Modifie la taille du tableau en ne gardant pas les valeurs actuelles.
void resizeDestructive(Int32 dim1_size)
Modifie la taille du tableau en ne gardant pas les valeurs actuelles.
constexpr Int32 dim1Size() const
Valeur de la première dimension.
NumArray(const DynamicDimsType &extents, eMemoryRessource r)
Construit un tableau en spécifiant directement la liste des dimensions.
NumArray()
Construit un tableau vide.
DataType operator()(Int32 i, Int32 j, Int32 k, Int32 l) const
Valeur pour l'élément i,j,k,l.
void fill(const DataType &v, SmallSpan< const Int32 > indexes, const RunQueue &queue)
Remplit via la file queue, les valeurs du tableau d'indices données par indexes par la valeur v .
constexpr Int32 extent3() const
Valeur de la quatrième dimension.
NumArray(Int32 dim1_size, Int32 dim2_size, Int32 dim3_size, Int32 dim4_size, eMemoryRessource r)
Construit un tableau avec 4 valeurs dynamiques.
void copy(SmallSpan< const DataType > rhs, const RunQueue *queue)
Copie dans l'instance les valeurs de rhs via la file queue.
constexpr Int32 dim2Size() const
Valeur de la deuxième dimension.
NumArray(Int32 dim1_size)
Construit un tableau avec 1 valeur dynamique.
void setDebugName(const String &str)
Positionne le nom du tableau pour les informations de debug.
ConstMDSpanType constMDSpan() const
Vue constante multi-dimension sur l'instance.
void resize(Int32 dim1_size, Int32 dim2_size, Int32 dim3_size, Int32 dim4_size)
Modifie la taille du tableau en ne gardant pas les valeurs actuelles.
constexpr Int32 extent2() const
Valeur de la troisième dimension.
void resize(Int32 dim1_size, Int32 dim2_size, Int32 dim3_size)
Modifie la taille du tableau en ne gardant pas les valeurs actuelles.
NumArray(Int32 dim1_size, Int32 dim2_size, std::initializer_list< DataType > alist)
Construit un tableau à partir de valeurs prédéfinies (tableaux 2D dynamiques).
NumArray(Int32 dim1_size, Int32 dim2_size, Int32 dim3_size, eMemoryRessource r)
Construit un tableau avec 3 valeurs dynamiques.
void copy(const ThatClass &rhs, const RunQueue &queue)
Copie dans l'instance les valeurs de rhs via la file queue.
NumArray(DynamicDimsType extents)
Construit un tableau en spécifiant directement la liste des dimensions.
NumArray(SmallSpan< const DataType > v)
Construit une instance à partir d'une vue (uniquement tableaux 1D dynamiques)
DataType & operator()(Int32 i, Int32 j, Int32 k, Int32 l)
Positionne la valeur pour l'élément i,j,k,l.
ArrayExtents< MDDim1 > extents() const
DataType operator[](Int32 i) const
Valeur pour l'élément i.
NumArray(Span< const DataType > v)
Construit une instance à partir d'une vue (uniquement tableaux 1D dynamiques)
constexpr Int64 totalNbElement() const
Nombre total d'éléments du tableau.
void resize(Int32 dim1_size)
Modifie la taille du tableau en gardant pas les valeurs actuelles.
Vue d'un tableau d'éléments de type T.
Definition Span.h:673
Vue d'un tableau d'éléments de type T.
Definition Span.h:513
Chaîne de caractères unicode.
Implémentation commune à pour NumArray.
Container pour la classe NumArray.
constexpr view_type smallView()
Vue constante sur cette vue.
Definition Span.h:273
constexpr ConstArrayView< value_type > constSmallView() const
Vue constante sur cette vue.
Definition Span.h:282
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Integer arcaneCheckArraySize(unsigned long long size)
Vérifie que size peut être converti dans un 'Integer' pour servir de taille à un tableau....
impl::SpanTypeFromSize< std::byte, SizeType >::SpanType asWritableBytes(const SpanImpl< DataType, SizeType, Extent > &s)
Converti la vue en un tableau d'octets modifiables.
Definition Span.h:919
std::int64_t Int64
Type entier signé sur 64 bits.
impl::SpanTypeFromSize< conststd::byte, SizeType >::SpanType asBytes(const SpanImpl< DataType, SizeType, Extent > &s)
Converti la vue en un tableau d'octets non modifiables.
Definition Span.h:884
Arcane::eMemoryResource eMemoryRessource
Typedef pour la version Arcane historique (avec 2's')
std::int32_t Int32
Type entier signé sur 32 bits.