d4/da8/UtilsTypes_8h_source.html

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-

//-----------------------------------------------------------------------------

// Copyright 2000-2025 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)

// See the top-level COPYRIGHT file for details.

// SPDX-License-Identifier: Apache-2.0

//-----------------------------------------------------------------------------

/*---------------------------------------------------------------------------*/

/* UtilsTypes.h                                                (C) 2000-2025 */

/*                                                                           */

/* Définition des types généraux des classes utilitaires de Arcane.          */

/*---------------------------------------------------------------------------*/

#ifndef ARCANE_UTILS_UTILSTYPES_H

#define ARCANE_UTILS_UTILSTYPES_H

/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


#include "arcane/utils/ArcaneGlobal.h"


#include "arccore/base/BaseTypes.h"

#include "arccore/base/RefDeclarations.h"

#include "arccore/collections/CollectionsGlobal.h"

#include "arccore/concurrency/ConcurrencyGlobal.h"

#include "arccore/trace/TraceGlobal.h"


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


namespace Arcane

{


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template<typename T> class MultiArray2View;

template<typename T> class ConstMultiArray2View;

template<typename T> class MultiArray2;

template<typename DataType> class UniqueMultiArray2;

template<typename DataType> class SharedMultiArray2;


template<typename T> class EnumeratorT;

template<typename T> class ListEnumeratorT;


template<typename T> class Collection;

template<typename T> class List;


class EventObservableBase;

class EventObserverBase;

template<typename... Args> class EventObservable;

template<typename... Args> class EventObserver;

template <typename... Args> class EventObservableView;


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


class Real2;

class Real3;

class Real2x2;

class Real3x3;

template <typename T> class Vector2;

template <typename T> class Vector3;

using Int64x3 = Vector3<Int64>;

using Int32x3 = Vector3<Int32>;

using Int64x2 = Vector2<Int64>;

using Int32x2 = Vector2<Int32>;

template<typename T,int Size> class NumVector;

template<typename T,int RowSize,int ColumnSize = RowSize> class NumMatrix;

using RealN2 = NumVector<Real,2>;

using RealN3 = NumVector<Real,3>;

using RealN2x2 = NumMatrix<Real,2>;

using RealN3x3 = NumMatrix<Real,3>;


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


class HPReal;

class JSONWriter;

class JSONValue;

class JSONDocument;

class JSONValueList;

class CommandLineArguments;

class ApplicationInfo;

class VersionInfo;


class IObservable;

class IObserver;

class Observable;

class Observer;


class ArrayShape;

class ConstMemoryView;

using MemoryView ARCANE_DEPRECATED_REASON("Use 'ConstMemoryView' instead") = ConstMemoryView;

class MutableMemoryView;


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


class IPerformanceCounterService;

class ForLoopTraceInfo;

class ForLoopOneExecStat;

namespace impl

{

class ForLoopStatInfoList;

class ForLoopStatInfoListImpl;

class ForLoopCumulativeStat;

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/

// Dans ConcurrencyUtils.h


class ParallelLoopOptions;

class ParallelFor1DLoopInfo;

class TaskContext;

class ITaskFunctor;

template<typename InstanceType>

class TaskFunctor;

template<typename InstanceType>

class TaskFunctorWithContext;

class ITask;

class ITaskImplementation;

class TaskFactory;


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


class ForLoopRange;

template<int RankValue, typename IndexType_ = Int32> class SimpleForLoopRanges;

template<int RankValue, typename IndexType_ = Int32> class ComplexForLoopRanges;


// Pour compatibilité avec l'existant (à supprimer après la version 3.8)

using LoopRange = ForLoopRange;

template<int RankValue> using SimpleLoopRanges = SimpleForLoopRanges<RankValue>;

template<int RankValue> using ComplexLoopRanges = ComplexForLoopRanges<RankValue>;


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


typedef Array<Pointer> PointerArray;

typedef Array<Byte> ByteArray;

typedef Array<UChar> UCharArray;

typedef Array<Int64> Int64Array;

typedef Array<Int32> Int32Array;

typedef Array<Int16> Int16Array;

typedef Array<Int8> Int8Array;

typedef Array<Integer> IntegerArray;

typedef Array<Real> RealArray;

typedef Array<BFloat16> BFloat16Array;

typedef Array<Float16> Float16Array;

typedef Array<Float32> Float32Array;

typedef Array<bool> BoolArray;

typedef Array<String> StringArray;

typedef Array<Real2> Real2Array;

typedef Array<Real3> Real3Array;

typedef Array<Real2x2> Real2x2Array;

typedef Array<Real3x3> Real3x3Array;


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


typedef Array2<Pointer> PointerArray2;

typedef Array2<Byte> ByteArray2;

typedef Array2<UChar> UCharArray2;

typedef Array2<Int64> Int64Array2;

typedef Array2<Int32> Int32Array2;

typedef Array2<Int16> Int16Array2;

typedef Array2<Int8> Int8Array2;

typedef Array2<Integer> IntegerArray2;

typedef Array2<Real> RealArray2;

typedef Array2<BFloat16> BFloat16Array2;

typedef Array2<Float16> Float16Array2;

typedef Array2<Float32> Float32Array2;

typedef Array2<bool> BoolArray2;

typedef Array2<String> StringArray2;

typedef Array2<Real2> Real2Array2;

typedef Array2<Real3> Real3Array2;

typedef Array2<Real2x2> Real2x2Array2;

typedef Array2<Real3x3> Real3x3Array2;


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


typedef SharedArray2<Pointer> PointerSharedArray2;

typedef SharedArray2<Byte> ByteSharedArray2;

typedef SharedArray2<UChar> UCharSharedArray2;

typedef SharedArray2<Int64> Int64SharedArray2;

typedef SharedArray2<Int32> Int32SharedArray2;

typedef SharedArray2<Int16> Int16SharedArray2;

typedef SharedArray2<Int8> Int8SharedArray2;

typedef SharedArray2<Integer> IntegerSharedArray2;

typedef SharedArray2<Real> RealSharedArray2;

typedef SharedArray2<BFloat16> BFloat16SharedArray2;

typedef SharedArray2<Float16> Float16SharedArray2;

typedef SharedArray2<Float32> Float32SharedArray2;

typedef SharedArray2<bool> BoolSharedArray2;

typedef SharedArray2<String> StringSharedArray2;

typedef SharedArray2<Real2> Real2SharedArray2;

typedef SharedArray2<Real3> Real3SharedArray2;

typedef SharedArray2<Real2x2> Real2x2SharedArray2;

typedef SharedArray2<Real3x3> Real3x3SharedArray2;


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


typedef UniqueArray2<Pointer> PointerUniqueArray2;

typedef UniqueArray2<Byte> ByteUniqueArray2;

typedef UniqueArray2<UChar> UCharUniqueArray2;

typedef UniqueArray2<Int64> Int64UniqueArray2;

typedef UniqueArray2<Int32> Int32UniqueArray2;

typedef UniqueArray2<Integer> IntegerUniqueArray2;

typedef UniqueArray2<Real> RealUniqueArray2;

typedef UniqueArray2<bool> BoolUniqueArray2;

typedef UniqueArray2<String> StringUniqueArray2;

typedef UniqueArray2<Real2> Real2UniqueArray2;

typedef UniqueArray2<Real3> Real3UniqueArray2;

typedef UniqueArray2<Real2x2> Real2x2UniqueArray2;

typedef UniqueArray2<Real3x3> Real3x3UniqueArray2;


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


typedef Array2View<Pointer> PointerArray2View;

typedef Array2View<Byte> ByteArray2View;

typedef Array2View<UChar> UCharArray2View;

typedef Array2View<Int64> Int64Array2View;

typedef Array2View<Int32> Int32Array2View;

typedef Array2View<Int16> Int16Array2View;

typedef Array2View<Integer> IntegerArray2View;

typedef Array2View<Real> RealArray2View;

typedef Array2View<bool> BoolArray2View;

typedef Array2View<String> StringArray2View;

typedef Array2View<Real2> Real2Array2View;

typedef Array2View<Real3> Real3Array2View;

typedef Array2View<Real2x2> Real2x2Array2View;

typedef Array2View<Real3x3> Real3x3Array2View;


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


typedef ConstArray2View<Pointer> PointerConstArray2View;

typedef ConstArray2View<Byte> ByteConstArray2View;

typedef ConstArray2View<UChar> UCharConstArray2View;

typedef ConstArray2View<Int64> Int64ConstArray2View;

typedef ConstArray2View<Int32> Int32ConstArray2View;

typedef ConstArray2View<Int16> Int16ConstArray2View;

typedef ConstArray2View<Integer> IntegerConstArray2View;

typedef ConstArray2View<Real> RealConstArray2View;

typedef ConstArray2View<bool> BoolConstArray2View;

typedef ConstArray2View<String> StringConstArray2View;

typedef ConstArray2View<Real2> Real2ConstArray2View;

typedef ConstArray2View<Real3> Real3ConstArray2View;

typedef ConstArray2View<Real2x2> Real2x2ConstArray2View;

typedef ConstArray2View<Real3x3> Real3x3ConstArray2View;


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


typedef UniqueArray<Pointer> PointerUniqueArray;

typedef UniqueArray<Byte> ByteUniqueArray;

typedef UniqueArray<UChar> UCharUniqueArray;

typedef UniqueArray<Int64> Int64UniqueArray;

typedef UniqueArray<Int32> Int32UniqueArray;

typedef UniqueArray<Int16> Int16UniqueArray;

typedef UniqueArray<Int8> Int8UniqueArray;

typedef UniqueArray<Integer> IntegerUniqueArray;

typedef UniqueArray<Real> RealUniqueArray;

typedef UniqueArray<BFloat16> BFloat16UniqueArray;

typedef UniqueArray<Float16> Float16UniqueArray;

typedef UniqueArray<Float32> Float32UniqueArray;

typedef UniqueArray<bool> BoolUniqueArray;

typedef UniqueArray<String> StringUniqueArray;

typedef UniqueArray<Real2> Real2UniqueArray;

typedef UniqueArray<Real3> Real3UniqueArray;

typedef UniqueArray<Real2x2> Real2x2UniqueArray;

typedef UniqueArray<Real3x3> Real3x3UniqueArray;


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


typedef SharedArray<Pointer> PointerSharedArray;

typedef SharedArray<Byte> ByteSharedArray;

typedef SharedArray<UChar> UCharSharedArray;

typedef SharedArray<Int64> Int64SharedArray;

typedef SharedArray<Int32> Int32SharedArray;

typedef SharedArray<Int16> Int16SharedArray;

typedef SharedArray<Int8> Int8SharedArray;

typedef SharedArray<Integer> IntegerSharedArray;

typedef SharedArray<Real> RealSharedArray;

typedef SharedArray<BFloat16> BFloat16SharedArray;

typedef SharedArray<Float16> Float16SharedArray;

typedef SharedArray<Float32> Float32SharedArray;

typedef SharedArray<bool> BoolSharedArray;

typedef SharedArray<String> StringSharedArray;

typedef SharedArray<Real2> Real2SharedArray;

typedef SharedArray<Real3> Real3SharedArray;

typedef SharedArray<Real2x2> Real2x2SharedArray;

typedef SharedArray<Real3x3> Real3x3SharedArray;


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


typedef MultiArray2<Pointer> PointerMultiArray2;

typedef MultiArray2<Byte> ByteMultiArray2;

typedef MultiArray2<UChar> UCharMultiArray2;

typedef MultiArray2<Int64> Int64MultiArray2;

typedef MultiArray2<Int32> Int32MultiArray2;

typedef MultiArray2<Int16> Int16MultiArray2;

typedef MultiArray2<Integer> IntegerMultiArray2;

typedef MultiArray2<Real> RealMultiArray2;

typedef MultiArray2<bool> BoolMultiArray2;

typedef MultiArray2<String> StringMultiArray2;

typedef MultiArray2<Real2> Real2MultiArray2;

typedef MultiArray2<Real3> Real3MultiArray2;

typedef MultiArray2<Real2x2> Real2x2MultiArray2;

typedef MultiArray2<Real3x3> Real3x3MultiArray2;


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


typedef ArrayView<Pointer> PointerArrayView;

typedef ArrayView<Byte> ByteArrayView;

typedef ArrayView<UChar> UCharArrayView;

typedef ArrayView<Int64> Int64ArrayView;

typedef ArrayView<Int32> Int32ArrayView;

typedef ArrayView<Int16> Int16ArrayView;

typedef ArrayView<Integer> IntegerArrayView;

typedef ArrayView<Real> RealArrayView;

typedef ArrayView<bool> BoolArrayView;

typedef ArrayView<String> StringArrayView;

typedef ArrayView<Real2> Real2ArrayView;

typedef ArrayView<Real3> Real3ArrayView;

typedef ArrayView<Real2x2> Real2x2ArrayView;

typedef ArrayView<Real3x3> Real3x3ArrayView;


typedef ConstArrayView<Pointer> PointerConstArrayView;

typedef ConstArrayView<Byte> ByteConstArrayView;

typedef ConstArrayView<UChar> UCharConstArrayView;

typedef ConstArrayView<Int64> Int64ConstArrayView;

typedef ConstArrayView<Int32> Int32ConstArrayView;

typedef ConstArrayView<Int16> Int16ConstArrayView;

typedef ConstArrayView<Integer> IntegerConstArrayView;

typedef ConstArrayView<Real> RealConstArrayView;

typedef ConstArrayView<bool> BoolConstArrayView;

typedef ConstArrayView<String> StringConstArrayView;

typedef ConstArrayView<Real2> Real2ConstArrayView;

typedef ConstArrayView<Real3> Real3ConstArrayView;

typedef ConstArrayView<Real2x2> Real2x2ConstArrayView;

typedef ConstArrayView<Real3x3> Real3x3ConstArrayView;


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


typedef Collection<String> StringCollection;


typedef List<String> StringList;


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


typedef Span<Pointer> PointerSpan;

typedef Span<std::byte> ByteSpan;

typedef Span<UChar> UCharSpan;

typedef Span<Int64> Int64Span;

typedef Span<Int32> Int32Span;

typedef Span<Int16> Int16Span;

typedef Span<Integer> IntegerSpan;

typedef Span<Real> RealSpan;

typedef Span<bool> BoolSpan;

typedef Span<Integer> IntegerSpan;

typedef Span<Real2> Real2Span;

typedef Span<Real3> Real3Span;

typedef Span<Real2x2> Real2x2Span;

typedef Span<Real3x3> Real3x3Span;


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


typedef Span<const Pointer> PointerConstSpan;

typedef Span<const std::byte> ByteConstSpan;

typedef Span<const UChar> UCharConstSpan;

typedef Span<const Int64> Int64ConstSpan;

typedef Span<const Int32> Int32ConstSpan;

typedef Span<const Int16> Int16ConstSpan;

typedef Span<const Integer> IntegerConstSpan;

typedef Span<const Real> RealConstSpan;

typedef Span<const bool> BoolConstSpan;

typedef Span<const Integer> IntegerConstSpan;

typedef Span<const Real2> Real2ConstSpan;

typedef Span<const Real3> Real3ConstSpan;

typedef Span<const Real2x2> Real2x2ConstSpan;

typedef Span<const Real3x3> Real3x3ConstSpan;


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


using PointerSmallSpan = SmallSpan<Pointer>;

using ByteSmallSpan = SmallSpan<std::byte>;

using UCharSmallSpan = SmallSpan<UChar>;

using Int64SmallSpan = SmallSpan<Int64>;

using Int32SmallSpan = SmallSpan<Int32>;

using Int16SmallSpan = SmallSpan<Int16>;

using IntegerSmallSpan = SmallSpan<Integer>;

using RealSmallSpan = SmallSpan<Real>;

using BoolSmallSpan = SmallSpan<bool>;

using IntegerSmallSpan = SmallSpan<Integer>;

using Real2SmallSpan = SmallSpan<Real2>;

using Real3SmallSpan = SmallSpan<Real3>;

using Real2x2SmallSpan = SmallSpan<Real2x2>;

using Real3x3SmallSpan = SmallSpan<Real3x3>;


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


using PointerConstSmallSpan = SmallSpan<const Pointer>;

using ByteConstSmallSpan = SmallSpan<const std::byte>;

using UCharConstSmallSpan = SmallSpan<const UChar>;

using Int64ConstSmallSpan = SmallSpan<const Int64>;

using Int32ConstSmallSpan = SmallSpan<const Int32>;

using Int16ConstSmallSpan = SmallSpan<const Int16>;

using IntegerConstSmallSpan = SmallSpan<const Integer>;

using RealConstSmallSpan = SmallSpan<const Real>;

using BoolConstSmallSpan = SmallSpan<const bool>;

using IntegerConstSmallSpan = SmallSpan<const Integer>;

using Real2ConstSmallSpan = SmallSpan<const Real2>;

using Real3ConstSmallSpan = SmallSpan<const Real3>;

using Real2x2ConstSmallSpan = SmallSpan<const Real2x2>;

using Real3x3ConstSmallSpan = SmallSpan<const Real3x3>;


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


} // End namespace Arcane


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


#endif

ArcaneGlobal.h
Fichier de configuration d'Arcane.

BaseTypes.h
Déclarations des types de la composante 'base' de Arccore.

RefDeclarations.h

Arcane::ApplicationInfo
Informations sur une application.
Definition ApplicationInfo.h:39

Arcane::Array2View
Vue modifiable pour un tableau 2D.
Definition arccore/src/base/arccore/base/Array2View.h:38

Arcane::Array2
Tableau 2D d'items de types quelconques.
Definition AnyItemArray2.h:55

Arcane::ArrayShape
Forme d'un tableau.
Definition ArrayShape.h:40

Arcane::ArrayView
Vue modifiable d'un tableau d'un type T.
Definition arccore/src/base/arccore/base/ArrayView.h:94

Arcane::Array
Tableau d'items de types quelconques.
Definition AnyItemArray.h:53

Arcane::Collection
Classe de base d'une collection fortement typée.
Definition Collection.h:115

Arcane::CommandLineArguments
Arguments de la ligne de commande.
Definition CommandLineArguments.h:49

Arcane::ComplexForLoopRanges
Interval d'itération complexe.
Definition ForLoopRanges.h:127

Arcane::ConstArray2View
Vue pour un tableau 2D constant.
Definition arccore/src/base/arccore/base/Array2View.h:132

Arcane::ConstArrayView
Vue constante d'un tableau de type T.
Definition arccore/src/base/arccore/base/ArrayView.h:533

Arcane::ConstMemoryView
Vue constante sur une zone mémoire contigue contenant des éléments de taille fixe.
Definition MemoryView.h:38

Arcane::ConstMultiArray2View
Vue constante sur un MultiArray2.
Definition MultiArray2View.h:88

Arcane::EnumeratorT
Enumérateur typé.
Definition Enumerator.h:136

Arcane::EventObservableBase
Classe de base d'un handler d'évènement.
Definition Event.h:35

Arcane::EventObservableView
Classe gérant les observateurs associés à un évènement.
Definition Event.h:248

Arcane::EventObservable
Classe de base d'un handler d'évènement.
Definition Event.h:193

Arcane::EventObserverBase
Classe de base d'un observateur d'évènement.
Definition Event.h:85

Arcane::EventObserver
Observateur d'évènements.
Definition Event.h:112

Arcane::ForLoopOneExecStat
Classe pour gérer le profiling d'une seule exécution d'une boucle.
Definition Profiling.h:93

Arcane::ForLoopRange
Intervalle d'itération pour une boucle.
Definition ForLoopRanges.h:50

Arcane::ForLoopTraceInfo
Informations de trace pour une boucle 'for'.
Definition ForLoopTraceInfo.h:32

Arcane::HPReal
Classe implémentant un réel Haute Précision.
Definition HPReal.h:161

Arcane::IObservable
Interface d'un observable.
Definition utils/IObservable.h:53

Arcane::IObserver
Interface d'un observateur.
Definition utils/IObserver.h:55

Arcane::IPerformanceCounterService
Interface d'un service d'accès aux compteurs de performance.
Definition IPerformanceCounterService.h:31

Arcane::ITaskFunctor
Interface d'un fonctor pour une tâche.
Definition ConcurrencyUtils.h:120

Arcane::ITaskImplementation
Implémentation d'une fabrique de tâches.
Definition ConcurrencyUtils.h:251

Arcane::ITask
Interface d'une tâche concourante.
Definition ConcurrencyUtils.h:213

Arcane::JSONDocument
Gestion d'un document JSON.
Definition JSONReader.h:230

Arcane::JSONValueList
Liste de valeurs d'un document JSON.
Definition JSONReader.h:199

Arcane::JSONValue
Représente une valeur JSON.
Definition JSONReader.h:43

Arcane::JSONWriter
Ecrivain au format JSON.
Definition JSONWriter.h:33

Arcane::ListEnumeratorT
Enumérateur typé pour un tableau.
Definition List.h:124

Arcane::List
Implémentation d'une collection d'éléments sous forme de vecteur.
Definition List.h:222

Arcane::MultiArray2View
Vue modifiable sur un MultiArray2.
Definition MultiArray2View.h:35

Arcane::MultiArray2
Classe de base des tableau 2D à taille multiple.
Definition MultiArray2.h:61

Arcane::MutableMemoryView
Vue modifiable sur une zone mémoire contigue contenant des éléments de taille fixe.
Definition MemoryView.h:156

Arcane::NumMatrix
Petite matrice de taille fixe contenant RowSize lignes et ColumnSize colonnes.
Definition NumMatrix.h:42

Arcane::NumVector
Petit vecteur de taille fixe de N données numériques.
Definition NumVector.h:43

Arcane::Observable
Classe de base d'un observable.
Definition utils/Observable.h:37

Arcane::ParallelFor1DLoopInfo
Caractéristiques d'un boucle 1D multi-thread.
Definition ConcurrencyUtils.h:611

Arcane::ParallelLoopOptions
Options d'exécution d'une boucle parallèle en multi-thread.
Definition ParallelLoopOptions.h:35

Arcane::Real2
Classe gérant un vecteur de réel de dimension 2.
Definition Real2.h:121

Arcane::Real2x2
Classe gérant une matrice de réel de dimension 2x2.
Definition Real2x2.h:53

Arcane::Real3
Classe gérant un vecteur de réel de dimension 3.
Definition Real3.h:132

Arcane::Real3x3
Classe gérant une matrice de réel de dimension 3x3.
Definition Real3x3.h:66

Arcane::SharedArray2
Vecteur de données 2D partagées avec sémantique par référence.
Definition arccore/src/collections/arccore/collections/Array2.h:541

Arcane::SharedArray
Vecteur 1D de données avec sémantique par référence.
Definition arccore/src/collections/arccore/collections/Array.h:1534

Arcane::SharedMultiArray2
Tableau 2D à taille multiple avec sémantique par référence.
Definition MultiArray2.h:320

Arcane::SimpleForLoopRanges
Interval d'itération simple.
Definition ForLoopRanges.h:85

Arcane::SmallSpan
Vue d'un tableau d'éléments de type T.
Definition Span.h:775

Arcane::Span
Vue d'un tableau d'éléments de type T.
Definition Span.h:613

Arcane::TaskContext
Contexte d'éxecution d'une tâche.
Definition ConcurrencyUtils.h:102

Arcane::TaskFactory
Fabrique pour les tâches.
Definition ConcurrencyUtils.h:329

Arcane::TaskFunctorWithContext
Fonctor pour une tâche prenant un TaskContext en argument.
Definition ConcurrencyUtils.h:179

Arcane::TaskFunctor
Fonctor sans argument pour une tâche.
Definition ConcurrencyUtils.h:142

Arcane::UniqueArray2
Vecteur de données 2D avec sémantique par valeur (style STL).
Definition arccore/src/collections/arccore/collections/Array2.h:714

Arcane::UniqueArray
Vecteur 1D de données avec sémantique par valeur (style STL).
Definition arccore/src/collections/arccore/collections/Array.h:1869

Arcane::UniqueMultiArray2
Tableau 2D à taille multiple avec sémantique par valeur.
Definition MultiArray2.h:375

Arcane::Vector2
Classe gérant un vecteur de dimension 2 de type T.
Definition Vector2.h:36

Arcane::Vector3
Classe gérant un vecteur de dimension 3 de type T.
Definition Vector3.h:36

Arcane::VersionInfo
Informations sur une version.
Definition VersionInfo.h:46

Arcane::impl::ForLoopCumulativeStat
Statistiques cumulées sur le nombre de boucles exécutées.
Definition ProfilingInternal.h:76

Arcane::impl::ForLoopStatInfoListImpl
Definition ProfilingInternal.h:59

Arcane::impl::ForLoopStatInfoList
Statistiques d'exécution des boucles.
Definition Profiling.h:56

Arcane
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Definition AcceleratorGlobal.h:36

Arcane::Real3UniqueArray2
UniqueArray2< Real3 > Real3UniqueArray2
Tableau dynamique 2D de vecteurs de rang 3.
Definition UtilsTypes.h:288

Arcane::Int32ConstArray2View
ConstArray2View< Int32 > Int32ConstArray2View
Tableau dynamique 2D d'entiers 32 bits.
Definition UtilsTypes.h:338

Arcane::RealArray2
Array2< Real > RealArray2
Tableau dynamique 2D de réels.
Definition UtilsTypes.h:204

Arcane::RealConstArray2View
ConstArray2View< Real > RealConstArray2View
Tableau dynamique 2D de réels.
Definition UtilsTypes.h:344

Arcane::PointerConstSmallSpan
SmallSpan< const Pointer > PointerConstSmallSpan
Vue en lecture seule d'un tableau à une dimension de pointeurs.
Definition UtilsTypes.h:639

Arcane::Int64SharedArray
SharedArray< Int64 > Int64SharedArray
Tableau dynamique à une dimension d'entiers 64 bits.
Definition UtilsTypes.h:408

Arcane::IntegerArray2
Array2< Integer > IntegerArray2
Tableau dynamique 2D d'entiers.
Definition UtilsTypes.h:202

Arcane::IntegerUniqueArray2
UniqueArray2< Integer > IntegerUniqueArray2
Tableau dynamique 2D d'entiers.
Definition UtilsTypes.h:278

Arcane::Real2Array
Array< Real2 > Real2Array
Tableau dynamique à une dimension de vecteurs de rang 2.
Definition UtilsTypes.h:176

Arcane::Real2x2SharedArray2
SharedArray2< Real2x2 > Real2x2SharedArray2
Tableau dynamique 2D de tenseurs de rang 2.
Definition UtilsTypes.h:260

Arcane::Int16ConstSmallSpan
SmallSpan< const Int16 > Int16ConstSmallSpan
Vue en lecture seule d'un tableau à une dimension d'entiers 16 bits.
Definition UtilsTypes.h:649

Arcane::PointerSharedArray
SharedArray< Pointer > PointerSharedArray
Tableau dynamique à une dimension de pointeurs.
Definition UtilsTypes.h:402

Arcane::RealArray2View
Array2View< Real > RealArray2View
Tableau dynamique 2D de réels.
Definition UtilsTypes.h:312

Arcane::Int8SharedArray2
SharedArray2< Int8 > Int8SharedArray2
Tableau dynamique 2D d'entiers 8 bits.
Definition UtilsTypes.h:240

Arcane::Real2x2UniqueArray
UniqueArray< Real2x2 > Real2x2UniqueArray
Tableau dynamique à une dimension de tenseurs de rang 2.
Definition UtilsTypes.h:394

Arcane::RealConstSpan
Span< const Real > RealConstSpan
Vue en lecture seule d'un tableau à une dimension de réels.
Definition UtilsTypes.h:589

Arcane::Int32Array2View
Array2View< Int32 > Int32Array2View
Tableau dynamique 2D d'entiers 32 bits.
Definition UtilsTypes.h:306

Arcane::Int64Array
Array< Int64 > Int64Array
Tableau dynamique à une dimension d'entiers 64 bits.
Definition UtilsTypes.h:154

Arcane::BoolArray2
Array2< bool > BoolArray2
Tableau dynamique 2D de booléens.
Definition UtilsTypes.h:212

Arcane::Int64ArrayView
ArrayView< Int64 > Int64ArrayView
Equivalent C d'un tableau à une dimension d'entiers 64 bits.
Definition UtilsTypes.h:480

Arcane::Float16SharedArray2
SharedArray2< Float16 > Float16SharedArray2
Tableau dynamique 2D de 'float16'.
Definition UtilsTypes.h:248

Arcane::StringSharedArray2
SharedArray2< String > StringSharedArray2
Tableau dynamique 2D de chaînes de caractères.
Definition UtilsTypes.h:254

Arcane::Real3x3ConstArray2View
ConstArray2View< Real3x3 > Real3x3ConstArray2View
Tableau dynamique 2D de tenseurs de rang 3.
Definition UtilsTypes.h:356

Arcane::Real2ConstSpan
Span< const Real2 > Real2ConstSpan
Vue en lecture seule d'un tableau à une dimension de Real2.
Definition UtilsTypes.h:595

Arcane::Int64Span
Span< Int64 > Int64Span
Equivalent C d'un tableau à une dimension d'entiers 64 bits.
Definition UtilsTypes.h:549

Arcane::Real3x3SharedArray2
SharedArray2< Real3x3 > Real3x3SharedArray2
Tableau dynamique 2D de tenseurs de rang 3.
Definition UtilsTypes.h:262

Arcane::Real3ConstArrayView
ConstArrayView< Real3 > Real3ConstArrayView
Equivalent C d'un tableau à une dimension de Real3.
Definition UtilsTypes.h:525

Arcane::Real3x3ConstSpan
Span< const Real3x3 > Real3x3ConstSpan
Vue en lecture seule d'un tableau à une dimension de Real3x3.
Definition UtilsTypes.h:601

Arcane::RealSharedArray
SharedArray< Real > RealSharedArray
Tableau dynamique à une dimension de réels.
Definition UtilsTypes.h:418

Arcane::Int16SharedArray2
SharedArray2< Int16 > Int16SharedArray2
Tableau dynamique 2D d'entiers 16 bits.
Definition UtilsTypes.h:238

Arcane::UCharConstSpan
Span< const UChar > UCharConstSpan
Vue en lecture seule d'un tableau à une dimension de caractères unicode.
Definition UtilsTypes.h:579

Arcane::Real3x3UniqueArray
UniqueArray< Real3x3 > Real3x3UniqueArray
Tableau dynamique à une dimension de tenseurs de rang 3.
Definition UtilsTypes.h:396

Arcane::IntegerArray2View
Array2View< Integer > IntegerArray2View
Tableau dynamique 2D d'entiers.
Definition UtilsTypes.h:310

Arcane::BoolUniqueArray2
UniqueArray2< bool > BoolUniqueArray2
Tableau dynamique 2D de booléens.
Definition UtilsTypes.h:282

Arcane::Real2x2SmallSpan
SmallSpan< Real2x2 > Real2x2SmallSpan
Vue d'un tableau à une dimension de Real2x2.
Definition UtilsTypes.h:631

Arcane::Float32SharedArray
SharedArray< Float32 > Float32SharedArray
Tableau dynamique à une dimension de 'float'.
Definition UtilsTypes.h:424

Arcane::Float32UniqueArray
UniqueArray< Float32 > Float32UniqueArray
Tableau dynamique à une dimension de 'float'.
Definition UtilsTypes.h:384

Arcane::Int32SharedArray2
SharedArray2< Int32 > Int32SharedArray2
Tableau dynamique 2D d'entiers 32 bits.
Definition UtilsTypes.h:236

Arcane::Real2UniqueArray2
UniqueArray2< Real2 > Real2UniqueArray2
Tableau dynamique 2D de vecteurs de rang 2.
Definition UtilsTypes.h:286

Arcane::Real3Array2View
Array2View< Real3 > Real3Array2View
Tableau dynamique 2D de vecteurs de rang 3.
Definition UtilsTypes.h:320

Arcane::RealMultiArray2
MultiArray2< Real > RealMultiArray2
Tableau 2D a taille variable de réels.
Definition UtilsTypes.h:456

Arcane::StringArrayView
ArrayView< String > StringArrayView
Equivalent C d'un tableau à une dimension de chaînes de caractères.
Definition UtilsTypes.h:492

Arcane::Int64UniqueArray
UniqueArray< Int64 > Int64UniqueArray
Tableau dynamique à une dimension d'entiers 64 bits.
Definition UtilsTypes.h:368

Arcane::BFloat16UniqueArray
UniqueArray< BFloat16 > BFloat16UniqueArray
Tableau dynamique à une dimension de 'bfloat16'.
Definition UtilsTypes.h:380

Arcane::StringConstArrayView
ConstArrayView< String > StringConstArrayView
Equivalent C d'un tableau à une dimension de chaînes de caractères.
Definition UtilsTypes.h:521

Arcane::StringArray
Array< String > StringArray
Tableau dynamique à une dimension de chaînes de caractères.
Definition UtilsTypes.h:174

Arcane::Int16ConstArray2View
ConstArray2View< Int16 > Int16ConstArray2View
Tableau dynamique 2D d'entiers 16 bits.
Definition UtilsTypes.h:340

Arcane::Int16Array2View
Array2View< Int16 > Int16Array2View
Tableau dynamique 2D d'entiers 16 bits.
Definition UtilsTypes.h:308

Arcane::Float16UniqueArray
UniqueArray< Float16 > Float16UniqueArray
Tableau dynamique à une dimension de 'float16'.
Definition UtilsTypes.h:382

Arcane::Float16SharedArray
SharedArray< Float16 > Float16SharedArray
Tableau dynamique à une dimension de 'float16'.
Definition UtilsTypes.h:422

Arcane::BoolArray
Array< bool > BoolArray
Tableau dynamique à une dimension de booléens.
Definition UtilsTypes.h:172

Arcane::UCharArray
Array< UChar > UCharArray
Tableau dynamique à une dimension de caractères unicode.
Definition UtilsTypes.h:152

Arcane::Real3x3Array2
Array2< Real3x3 > Real3x3Array2
Tableau dynamique 2D de tenseurs de rang 3.
Definition UtilsTypes.h:222

Arcane::ByteArray2
Array2< Byte > ByteArray2
Tableau dynamique 2D de caractères.
Definition UtilsTypes.h:190

Arcane::Real2x2ArrayView
ArrayView< Real2x2 > Real2x2ArrayView
Equivalent C d'un tableau à une dimension de Real2x2.
Definition UtilsTypes.h:498

Arcane::ByteArrayView
ArrayView< Byte > ByteArrayView
Equivalent C d'un tableau à une dimension de caractères.
Definition UtilsTypes.h:476

Arcane::Int8SharedArray
SharedArray< Int8 > Int8SharedArray
Tableau dynamique à une dimension d'entiers 16 bits.
Definition UtilsTypes.h:414

Arcane::BoolConstArray2View
ConstArray2View< bool > BoolConstArray2View
Tableau dynamique 2D de booléens.
Definition UtilsTypes.h:346

Arcane::BoolArrayView
ArrayView< bool > BoolArrayView
Equivalent C d'un tableau à une dimension de booléens.
Definition UtilsTypes.h:490

Arcane::Int64ConstSpan
Span< const Int64 > Int64ConstSpan
Vue en lecture seule d'un tableau à une dimension d'entiers 64 bits.
Definition UtilsTypes.h:581

Arcane::Real3ArrayView
ArrayView< Real3 > Real3ArrayView
Equivalent C d'un tableau à une dimension de Real3.
Definition UtilsTypes.h:496

Arcane::UCharSmallSpan
SmallSpan< UChar > UCharSmallSpan
Vue d'un tableau à une dimension de caractères unicode.
Definition UtilsTypes.h:611

Arcane::Real3x3Array
Array< Real3x3 > Real3x3Array
Tableau dynamique à une dimension de tenseurs de rang 3.
Definition UtilsTypes.h:182

Arcane::Real2MultiArray2
MultiArray2< Real2 > Real2MultiArray2
Tableau 2D a taille variable de vecteurs de rang 2.
Definition UtilsTypes.h:462

Arcane::Int16Array
Array< Int16 > Int16Array
Tableau dynamique à une dimension d'entiers 16 bits.
Definition UtilsTypes.h:158

Arcane::IntegerConstArray2View
ConstArray2View< Integer > IntegerConstArray2View
Tableau dynamique 2D d'entiers.
Definition UtilsTypes.h:342

Arcane::UCharArrayView
ArrayView< UChar > UCharArrayView
Equivalent C d'un tableau à une dimension de caractères unicode.
Definition UtilsTypes.h:478

Arcane::Int64SharedArray2
SharedArray2< Int64 > Int64SharedArray2
Tableau dynamique 2D d'entiers 64 bits.
Definition UtilsTypes.h:234

Arcane::Float16Array
Array< Float16 > Float16Array
Tableau dynamique à une dimension de 'float16'.
Definition UtilsTypes.h:168

Arcane::ByteArray
Array< Byte > ByteArray
Tableau dynamique à une dimension de caractères.
Definition UtilsTypes.h:150

Arcane::Int64Array2
Array2< Int64 > Int64Array2
Tableau dynamique 2D d'entiers 64 bits.
Definition UtilsTypes.h:194

Arcane::PointerConstArrayView
ConstArrayView< Pointer > PointerConstArrayView
Equivalent C d'un tableau à une dimension de pointeurs.
Definition UtilsTypes.h:503

Arcane::Int64ConstArray2View
ConstArray2View< Int64 > Int64ConstArray2View
Tableau dynamique 2D d'entiers 64 bits.
Definition UtilsTypes.h:336

Arcane::BFloat16Array
Array< BFloat16 > BFloat16Array
Tableau dynamique à une dimension de 'bfloat16'.
Definition UtilsTypes.h:166

Arcane::Real3UniqueArray
UniqueArray< Real3 > Real3UniqueArray
Tableau dynamique à une dimension de vecteurs de rang 3.
Definition UtilsTypes.h:392

Arcane::Int16Array2
Array2< Int16 > Int16Array2
Tableau dynamique 2D d'entiers 16 bits.
Definition UtilsTypes.h:198

Arcane::Int16ArrayView
ArrayView< Int16 > Int16ArrayView
Equivalent C d'un tableau à une dimension d'entiers 16 bits.
Definition UtilsTypes.h:484

Arcane::Int32ConstArrayView
ConstArrayView< Int32 > Int32ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:511

Arcane::BoolConstArrayView
ConstArrayView< bool > BoolConstArrayView
Equivalent C d'un tableau à une dimension de booléens.
Definition UtilsTypes.h:519

Arcane::Real3SharedArray
SharedArray< Real3 > Real3SharedArray
Tableau dynamique à une dimension de vecteurs de rang 3.
Definition UtilsTypes.h:432

Arcane::Int64Array2View
Array2View< Int64 > Int64Array2View
Tableau dynamique 2D d'entiers 64 bits.
Definition UtilsTypes.h:304

Arcane::Int16UniqueArray
UniqueArray< Int16 > Int16UniqueArray
Tableau dynamique à une dimension d'entiers 16 bits.
Definition UtilsTypes.h:372

Arcane::StringUniqueArray2
UniqueArray2< String > StringUniqueArray2
Tableau dynamique 2D de chaînes de caractères.
Definition UtilsTypes.h:284

Arcane::StringCollection
Collection< String > StringCollection
Collection de chaînes de caractères.
Definition UtilsTypes.h:535

Arcane::Real2Array2
Array2< Real2 > Real2Array2
Tableau dynamique 2D de vecteurs de rang 2.
Definition UtilsTypes.h:216

Arcane::UCharArray2
Array2< UChar > UCharArray2
Tableau dynamique 2D de caractères unicode.
Definition UtilsTypes.h:192

Arcane::Real3x3ArrayView
ArrayView< Real3x3 > Real3x3ArrayView
Equivalent C d'un tableau à une dimension de Real3x3.
Definition UtilsTypes.h:500

Arcane::BoolUniqueArray
UniqueArray< bool > BoolUniqueArray
Tableau dynamique à une dimension de booléens.
Definition UtilsTypes.h:386

Arcane::Real3x3Span
Span< Real3x3 > Real3x3Span
Equivalent C d'un tableau à une dimension de Real3x3.
Definition UtilsTypes.h:569

Arcane::IntegerSmallSpan
SmallSpan< Integer > IntegerSmallSpan
Vue d'un tableau à une dimension d'entiers.
Definition UtilsTypes.h:619

Arcane::IntegerSharedArray2
SharedArray2< Integer > IntegerSharedArray2
Tableau dynamique 2D d'entiers.
Definition UtilsTypes.h:242

Arcane::ByteConstSmallSpan
SmallSpan< const std::byte > ByteConstSmallSpan
Vue en lecture seule d'un tableau à une dimension de caractères.
Definition UtilsTypes.h:641

Arcane::IntegerConstSmallSpan
SmallSpan< const Integer > IntegerConstSmallSpan
Vue en lecture seule d'un tableau à une dimension d'entiers.
Definition UtilsTypes.h:651

Arcane::PointerArray2
Array2< Pointer > PointerArray2
Tableau dynamique 2D de pointeurs.
Definition UtilsTypes.h:188

Arcane::Int8Array
Array< Int8 > Int8Array
Tableau dynamique à une dimension d'entiers 8 bits.
Definition UtilsTypes.h:160

Arcane::UCharUniqueArray
UniqueArray< UChar > UCharUniqueArray
Tableau dynamique à une dimension de caractères unicode.
Definition UtilsTypes.h:366

Arcane::PointerMultiArray2
MultiArray2< Pointer > PointerMultiArray2
Tableau 2D a taille variable de pointeurs.
Definition UtilsTypes.h:442

Arcane::Real2x2MultiArray2
MultiArray2< Real2x2 > Real2x2MultiArray2
Tableau 2D a taille variable de tenseurs de rang 2.
Definition UtilsTypes.h:466

Arcane::Real2ConstSmallSpan
SmallSpan< const Real2 > Real2ConstSmallSpan
Vue en lecture seule d'un tableau à une dimension de Real2.
Definition UtilsTypes.h:659

Arcane::IntegerArrayView
ArrayView< Integer > IntegerArrayView
Equivalent C d'un tableau à une dimension d'entiers.
Definition UtilsTypes.h:486

Arcane::Float16Array2
Array2< Float16 > Float16Array2
Tableau dynamique 2D de 'float16'.
Definition UtilsTypes.h:208

Arcane::UCharSpan
Span< UChar > UCharSpan
Equivalent C d'un tableau à une dimension de caractères unicode.
Definition UtilsTypes.h:547

Arcane::RealConstSmallSpan
SmallSpan< const Real > RealConstSmallSpan
Vue en lecture seule d'un tableau à une dimension de réels.
Definition UtilsTypes.h:653

Arcane::PointerConstArray2View
ConstArray2View< Pointer > PointerConstArray2View
Tableau dynamique 2D de pointeurs.
Definition UtilsTypes.h:330

Arcane::BoolConstSpan
Span< const bool > BoolConstSpan
Vue en lecture seule d'un tableau à une dimension de booléens.
Definition UtilsTypes.h:591

Arcane::IntegerArray
Array< Integer > IntegerArray
Tableau dynamique à une dimension d'entiers.
Definition UtilsTypes.h:162

Arcane::Int16ConstArrayView
ConstArrayView< Int16 > Int16ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 16 bits.
Definition UtilsTypes.h:513

Arcane::Real2x2Span
Span< Real2x2 > Real2x2Span
Equivalent C d'un tableau à une dimension de Real2x2.
Definition UtilsTypes.h:567

Arcane::IntegerMultiArray2
MultiArray2< Integer > IntegerMultiArray2
Tableau 2D a taille variable d'entiers.
Definition UtilsTypes.h:454

Arcane::ByteUniqueArray2
UniqueArray2< Byte > ByteUniqueArray2
Tableau dynamique 2D de caractères.
Definition UtilsTypes.h:270

Arcane::Int64MultiArray2
MultiArray2< Int64 > Int64MultiArray2
Tableau 2D a taille variable d'entiers 64 bits.
Definition UtilsTypes.h:448

Arcane::PointerConstSpan
Span< const Pointer > PointerConstSpan
Vue en lecture seule d'un tableau à une dimension de pointeurs.
Definition UtilsTypes.h:575

Arcane::StringArray2View
Array2View< String > StringArray2View
Tableau dynamique 2D de chaînes de caractères.
Definition UtilsTypes.h:316

Arcane::StringConstArray2View
ConstArray2View< String > StringConstArray2View
Tableau dynamique 2D de chaînes de caractères.
Definition UtilsTypes.h:348

Arcane::Int64UniqueArray2
UniqueArray2< Int64 > Int64UniqueArray2
Tableau dynamique 2D d'entiers 64 bits.
Definition UtilsTypes.h:274

Arcane::Int32SmallSpan
SmallSpan< Int32 > Int32SmallSpan
Vue d'un tableau à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:615

Arcane::Int64ConstArrayView
ConstArrayView< Int64 > Int64ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 64 bits.
Definition UtilsTypes.h:509

Arcane::ByteUniqueArray
UniqueArray< Byte > ByteUniqueArray
Tableau dynamique à une dimension de caractères.
Definition UtilsTypes.h:364

Arcane::ByteArray2View
Array2View< Byte > ByteArray2View
Tableau dynamique 2D de caractères.
Definition UtilsTypes.h:300

Arcane::IntegerSpan
Span< Integer > IntegerSpan
Equivalent C d'un tableau à une dimension d'entiers.
Definition UtilsTypes.h:555

Arcane::PointerSharedArray2
SharedArray2< Pointer > PointerSharedArray2
Tableau dynamique 2D de pointeurs.
Definition UtilsTypes.h:228

Arcane::StringSharedArray
SharedArray< String > StringSharedArray
Tableau dynamique à une dimension de chaînes de caractères.
Definition UtilsTypes.h:428

Arcane::StringArray2
Array2< String > StringArray2
Tableau dynamique 2D de chaînes de caractères.
Definition UtilsTypes.h:214

Arcane::Float32Array2
Array2< Float32 > Float32Array2
Tableau dynamique 2D de 'float'.
Definition UtilsTypes.h:210

Arcane::BFloat16SharedArray
SharedArray< BFloat16 > BFloat16SharedArray
Tableau dynamique à une dimension de 'bfloat16'.
Definition UtilsTypes.h:420

Arcane::BoolSpan
Span< bool > BoolSpan
Equivalent C d'un tableau à une dimension de booléens.
Definition UtilsTypes.h:559

Arcane::UCharConstSmallSpan
SmallSpan< const UChar > UCharConstSmallSpan
Vue en lecture seule d'un tableau à une dimension de caractères unicode.
Definition UtilsTypes.h:643

Arcane::Int16SmallSpan
SmallSpan< Int16 > Int16SmallSpan
Vue d'un tableau à une dimension d'entiers 16 bits.
Definition UtilsTypes.h:617

Arcane::Real3ConstSmallSpan
SmallSpan< const Real3 > Real3ConstSmallSpan
Vue en lecture seule d'un tableau à une dimension de Real3.
Definition UtilsTypes.h:661

Arcane::Int32MultiArray2
MultiArray2< Int32 > Int32MultiArray2
Tableau 2D a taille variable d'entiers 32 bits.
Definition UtilsTypes.h:450

Arcane::Int32SharedArray
SharedArray< Int32 > Int32SharedArray
Tableau dynamique à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:410

Arcane::ByteSharedArray2
SharedArray2< Byte > ByteSharedArray2
Tableau dynamique 2D de caractères.
Definition UtilsTypes.h:230

Arcane::Int32UniqueArray
UniqueArray< Int32 > Int32UniqueArray
Tableau dynamique à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:370

Arcane::Real2x2ConstArray2View
ConstArray2View< Real2x2 > Real2x2ConstArray2View
Tableau dynamique 2D de tenseurs de rang 2.
Definition UtilsTypes.h:354

Arcane::StringList
List< String > StringList
Tableau de chaînes de caractères unicode.
Definition UtilsTypes.h:538

Arcane::Real3x3SharedArray
SharedArray< Real3x3 > Real3x3SharedArray
Tableau dynamique à une dimension de tenseurs de rang 3.
Definition UtilsTypes.h:436

Arcane::StringMultiArray2
MultiArray2< String > StringMultiArray2
Tableau 2D a taille variable de chaînes de caractères.
Definition UtilsTypes.h:460

Arcane::RealSharedArray2
SharedArray2< Real > RealSharedArray2
Tableau dynamique 2D de réels.
Definition UtilsTypes.h:244

Arcane::Real3MultiArray2
MultiArray2< Real3 > Real3MultiArray2
Tableau 2D a taille variable de vecteurs de rang 3.
Definition UtilsTypes.h:464

Arcane::Real2Array2View
Array2View< Real2 > Real2Array2View
Tableau dynamique 2D de vecteurs de rang 2.
Definition UtilsTypes.h:318

Arcane::Int32ArrayView
ArrayView< Int32 > Int32ArrayView
Equivalent C d'un tableau à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:482

Arcane::IntegerConstSpan
Span< const Integer > IntegerConstSpan
Vue en lecture seule d'un tableau à une dimension d'entiers.
Definition UtilsTypes.h:587

Arcane::Real3x3MultiArray2
MultiArray2< Real3x3 > Real3x3MultiArray2
Tableau 2D a taille variable de tenseurs de rang 3.
Definition UtilsTypes.h:468

Arcane::BoolSharedArray
SharedArray< bool > BoolSharedArray
Tableau dynamique à une dimension de booléens.
Definition UtilsTypes.h:426

Arcane::PointerUniqueArray
UniqueArray< Pointer > PointerUniqueArray
Tableau dynamique à une dimension de pointeurs.
Definition UtilsTypes.h:362

Arcane::RealUniqueArray
UniqueArray< Real > RealUniqueArray
Tableau dynamique à une dimension de réels.
Definition UtilsTypes.h:378

Arcane::RealUniqueArray2
UniqueArray2< Real > RealUniqueArray2
Tableau dynamique 2D de réels.
Definition UtilsTypes.h:280

Arcane::BoolSmallSpan
SmallSpan< bool > BoolSmallSpan
Vue d'un tableau à une dimension de booléens.
Definition UtilsTypes.h:623

Arcane::Int8Array2
Array2< Int8 > Int8Array2
Tableau dynamique 2D d'entiers 8 bits.
Definition UtilsTypes.h:200

Arcane::Int64ConstSmallSpan
SmallSpan< const Int64 > Int64ConstSmallSpan
Vue en lecture seule d'un tableau à une dimension d'entiers 64 bits.
Definition UtilsTypes.h:645

Arcane::BFloat16SharedArray2
SharedArray2< BFloat16 > BFloat16SharedArray2
Tableau dynamique 2D de 'bfloat16'.
Definition UtilsTypes.h:246

Arcane::Float32SharedArray2
SharedArray2< Float32 > Float32SharedArray2
Tableau dynamique 2D de 'float'.
Definition UtilsTypes.h:250

Arcane::UCharUniqueArray2
UniqueArray2< UChar > UCharUniqueArray2
Tableau dynamique 2D de caractères unicode.
Definition UtilsTypes.h:272

Arcane::PointerSpan
Span< Pointer > PointerSpan
Equivalent C d'un tableau à une dimension de pointeurs.
Definition UtilsTypes.h:543

Arcane::UCharConstArrayView
ConstArrayView< UChar > UCharConstArrayView
Equivalent C d'un tableau à une dimension de caractères unicode.
Definition UtilsTypes.h:507

Arcane::ByteConstArrayView
ConstArrayView< Byte > ByteConstArrayView
Equivalent C d'un tableau à une dimension de caractères.
Definition UtilsTypes.h:505

Arcane::RealSmallSpan
SmallSpan< Real > RealSmallSpan
Vue d'un tableau à une dimension de réels.
Definition UtilsTypes.h:621

Arcane::Real2x2Array
Array< Real2x2 > Real2x2Array
Tableau dynamique à une dimension de tenseurs de rang 2.
Definition UtilsTypes.h:180

Arcane::PointerSmallSpan
SmallSpan< Pointer > PointerSmallSpan
Vue d'un tableau à une dimension de pointeurs.
Definition UtilsTypes.h:607

Arcane::Int32Array
Array< Int32 > Int32Array
Tableau dynamique à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:156

Arcane::RealArray
Array< Real > RealArray
Tableau dynamique à une dimension de réels.
Definition UtilsTypes.h:164

Arcane::Real2ConstArrayView
ConstArrayView< Real2 > Real2ConstArrayView
Equivalent C d'un tableau à une dimension de Real2.
Definition UtilsTypes.h:523

Arcane::StringUniqueArray
UniqueArray< String > StringUniqueArray
Tableau dynamique à une dimension de chaînes de caractères.
Definition UtilsTypes.h:388

Arcane::Real3Array2
Array2< Real3 > Real3Array2
Tableau dynamique 2D de vecteurs de rang 3.
Definition UtilsTypes.h:218

Arcane::IntegerSharedArray
SharedArray< Integer > IntegerSharedArray
Tableau dynamique à une dimension d'entiers.
Definition UtilsTypes.h:416

Arcane::BoolSharedArray2
SharedArray2< bool > BoolSharedArray2
Tableau dynamique 2D de booléens.
Definition UtilsTypes.h:252

Arcane::PointerArray2View
Array2View< Pointer > PointerArray2View
Tableau dynamique 2D de pointeurs.
Definition UtilsTypes.h:298

Arcane::Int16SharedArray
SharedArray< Int16 > Int16SharedArray
Tableau dynamique à une dimension d'entiers 16 bits.
Definition UtilsTypes.h:412

Arcane::UCharConstArray2View
ConstArray2View< UChar > UCharConstArray2View
Tableau dynamique 2D de caractères unicode.
Definition UtilsTypes.h:334

Arcane::Real2SharedArray2
SharedArray2< Real2 > Real2SharedArray2
Tableau dynamique 2D de vecteurs de rang 2.
Definition UtilsTypes.h:256

Arcane::Int16Span
Span< Int16 > Int16Span
Equivalent C d'un tableau à une dimension d'entiers 16 bits.
Definition UtilsTypes.h:553

Arcane::Real2ConstArray2View
ConstArray2View< Real2 > Real2ConstArray2View
Tableau dynamique 2D de vecteurs de rang 2.
Definition UtilsTypes.h:350

Arcane::Real2x2SharedArray
SharedArray< Real2x2 > Real2x2SharedArray
Tableau dynamique à une dimension de tenseurs de rang 2.
Definition UtilsTypes.h:434

Arcane::BoolArray2View
Array2View< bool > BoolArray2View
Tableau dynamique 2D de booléens.
Definition UtilsTypes.h:314

Arcane::UCharSharedArray
SharedArray< UChar > UCharSharedArray
Tableau dynamique à une dimension de caractères unicode.
Definition UtilsTypes.h:406

Arcane::RealSpan
Span< Real > RealSpan
Equivalent C d'un tableau à une dimension de réels.
Definition UtilsTypes.h:557

Arcane::Int32Span
Span< Int32 > Int32Span
Equivalent C d'un tableau à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:551

Arcane::Int16ConstSpan
Span< const Int16 > Int16ConstSpan
Vue en lecture seule d'un tableau à une dimension d'entiers 16 bits.
Definition UtilsTypes.h:585

Arcane::Real2x2ConstSmallSpan
SmallSpan< const Real2x2 > Real2x2ConstSmallSpan
Vue en lecture seule d'un tableau à une dimension de Real2x2.
Definition UtilsTypes.h:663

Arcane::Real3x3Array2View
Array2View< Real3x3 > Real3x3Array2View
Tableau dynamique 2D de tenseurs de rang 3.
Definition UtilsTypes.h:324

Arcane::Int32UniqueArray2
UniqueArray2< Int32 > Int32UniqueArray2
Tableau dynamique 2D d'entiers 32 bits.
Definition UtilsTypes.h:276

Arcane::Real2ArrayView
ArrayView< Real2 > Real2ArrayView
Equivalent C d'un tableau à une dimension de Real2.
Definition UtilsTypes.h:494

Arcane::Real2UniqueArray
UniqueArray< Real2 > Real2UniqueArray
Tableau dynamique à une dimension de vecteurs de rang 2.
Definition UtilsTypes.h:390

Arcane::Real2SharedArray
SharedArray< Real2 > Real2SharedArray
Tableau dynamique à une dimension de vecteurs de rang 2.
Definition UtilsTypes.h:430

Arcane::Real3x3SmallSpan
SmallSpan< Real3x3 > Real3x3SmallSpan
Vue d'un tableau à une dimension de Real3x3.
Definition UtilsTypes.h:633

Arcane::Real2SmallSpan
SmallSpan< Real2 > Real2SmallSpan
Vue d'un tableau à une dimension de Real2.
Definition UtilsTypes.h:627

Arcane::Real3ConstArray2View
ConstArray2View< Real3 > Real3ConstArray2View
Tableau dynamique 2D de vecteurs de rang 3.
Definition UtilsTypes.h:352

Arcane::Int32ConstSpan
Span< const Int32 > Int32ConstSpan
Vue en lecture seule d'un tableau à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:583

Arcane::BoolConstSmallSpan
SmallSpan< const bool > BoolConstSmallSpan
Vue en lecture seule d'un tableau à une dimension de booléens.
Definition UtilsTypes.h:655

Arcane::ByteSmallSpan
SmallSpan< std::byte > ByteSmallSpan
Vue d'un tableau à une dimension de caractères.
Definition UtilsTypes.h:609

Arcane::IntegerUniqueArray
UniqueArray< Integer > IntegerUniqueArray
Tableau dynamique à une dimension d'entiers.
Definition UtilsTypes.h:376

Arcane::BoolMultiArray2
MultiArray2< bool > BoolMultiArray2
Tableau 2D a taille variable de booléens.
Definition UtilsTypes.h:458

Arcane::UCharArray2View
Array2View< UChar > UCharArray2View
Tableau dynamique 2D de caractères unicode.
Definition UtilsTypes.h:302

Arcane::Real2x2UniqueArray2
UniqueArray2< Real2x2 > Real2x2UniqueArray2
Tableau dynamique 2D de tenseurs de rang 2.
Definition UtilsTypes.h:290

Arcane::Real2x2Array2View
Array2View< Real2x2 > Real2x2Array2View
Tableau dynamique 2D de tenseurs de rang 2.
Definition UtilsTypes.h:322

Arcane::Real3SharedArray2
SharedArray2< Real3 > Real3SharedArray2
Tableau dynamique 2D de vecteurs de rang 3.
Definition UtilsTypes.h:258

Arcane::Int32ConstSmallSpan
SmallSpan< const Int32 > Int32ConstSmallSpan
Vue en lecture seule d'un tableau à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:647

Arcane::Real3x3UniqueArray2
UniqueArray2< Real3x3 > Real3x3UniqueArray2
Tableau dynamique 2D de tenseurs de rang 3.
Definition UtilsTypes.h:292

Arcane::IntegerConstArrayView
ConstArrayView< Integer > IntegerConstArrayView
Equivalent C d'un tableau à une dimension d'entiers.
Definition UtilsTypes.h:515

Arcane::Int32Array2
Array2< Int32 > Int32Array2
Tableau dynamique 2D d'entiers 32 bits.
Definition UtilsTypes.h:196

Arcane::Real3Span
Span< Real3 > Real3Span
Equivalent C d'un tableau à une dimension de Real3.
Definition UtilsTypes.h:565

Arcane::Real3SmallSpan
SmallSpan< Real3 > Real3SmallSpan
Vue d'un tableau à une dimension de Real3.
Definition UtilsTypes.h:629

Arcane::Float32Array
Array< Float32 > Float32Array
Tableau dynamique à une dimension de 'float'.
Definition UtilsTypes.h:170

Arcane::Int8UniqueArray
UniqueArray< Int8 > Int8UniqueArray
Tableau dynamique à une dimension d'entiers 16 bits.
Definition UtilsTypes.h:374

Arcane::BFloat16Array2
Array2< BFloat16 > BFloat16Array2
Tableau dynamique 2D de 'bfloat16'.
Definition UtilsTypes.h:206

Arcane::RealArrayView
ArrayView< Real > RealArrayView
Equivalent C d'un tableau à une dimension de réels.
Definition UtilsTypes.h:488

Arcane::ByteConstArray2View
ConstArray2View< Byte > ByteConstArray2View
Tableau dynamique 2D de caractères.
Definition UtilsTypes.h:332

Arcane::Real3x3ConstSmallSpan
SmallSpan< const Real3x3 > Real3x3ConstSmallSpan
Vue en lecture seule d'un tableau à une dimension de Real3x3.
Definition UtilsTypes.h:665

Arcane::Real3x3ConstArrayView
ConstArrayView< Real3x3 > Real3x3ConstArrayView
Equivalent C d'un tableau à une dimension de Real3x3.
Definition UtilsTypes.h:529

Arcane::UCharSharedArray2
SharedArray2< UChar > UCharSharedArray2
Tableau dynamique 2D de caractères unicode.
Definition UtilsTypes.h:232

Arcane::Real2x2ConstSpan
Span< const Real2x2 > Real2x2ConstSpan
Vue en lecture seule d'un tableau à une dimension de Real2x2.
Definition UtilsTypes.h:599

Arcane::ByteMultiArray2
MultiArray2< Byte > ByteMultiArray2
Tableau 2D a taille variable de caractères.
Definition UtilsTypes.h:444

Arcane::Real2x2ConstArrayView
ConstArrayView< Real2x2 > Real2x2ConstArrayView
Equivalent C d'un tableau à une dimension de Real2x2.
Definition UtilsTypes.h:527

Arcane::Real3ConstSpan
Span< const Real3 > Real3ConstSpan
Vue en lecture seule d'un tableau à une dimension de Real3.
Definition UtilsTypes.h:597

Arcane::Real2x2Array2
Array2< Real2x2 > Real2x2Array2
Tableau dynamique 2D de tenseurs de rang 2.
Definition UtilsTypes.h:220

Arcane::Real2Span
Span< Real2 > Real2Span
Equivalent C d'un tableau à une dimension de Real2.
Definition UtilsTypes.h:563

Arcane::Int16MultiArray2
MultiArray2< Int16 > Int16MultiArray2
Tableau 2D a taille variable d'entiers 16 bits.
Definition UtilsTypes.h:452

Arcane::PointerUniqueArray2
UniqueArray2< Pointer > PointerUniqueArray2
Tableau dynamique 2D de pointeurs.
Definition UtilsTypes.h:268

Arcane::UCharMultiArray2
MultiArray2< UChar > UCharMultiArray2
Tableau 2D a taille variable de caractères unicode.
Definition UtilsTypes.h:446

Arcane::ByteSharedArray
SharedArray< Byte > ByteSharedArray
Tableau dynamique à une dimension de caractères.
Definition UtilsTypes.h:404

Arcane::Real3Array
Array< Real3 > Real3Array
Tableau dynamique à une dimension de vecteurs de rang 3.
Definition UtilsTypes.h:178

Arcane::PointerArray
Array< Pointer > PointerArray
Tableau dynamique à une dimension de pointeurs.
Definition UtilsTypes.h:148

Arcane::PointerArrayView
ArrayView< Pointer > PointerArrayView
Equivalent C d'un tableau à une dimension de pointeurs.
Definition UtilsTypes.h:474

Arcane::Int64SmallSpan
SmallSpan< Int64 > Int64SmallSpan
Vue d'un tableau à une dimension d'entiers 64 bits.
Definition UtilsTypes.h:613

Arcane::RealConstArrayView
ConstArrayView< Real > RealConstArrayView
Equivalent C d'un tableau à une dimension de réels.
Definition UtilsTypes.h:517