atlas  0.6
Atlas.h
Go to the documentation of this file.
1 /*
2  This is Atlas.h
3 
4  Copyright (C) 2011 Marc van Leeuwen
5  part of the Atlas of Lie Groups and Representations
6 
7  For license information see the LICENSE file
8 */
9 
10 #ifndef ATLAS_H /* guard against multiple inclusions */
11 #define ATLAS_H
12 
13 /* Forward declarations of classes and types for atlas namespace.
14 
15  This module defines types in the (global) atlas namespace that can be
16  therefore used in short form by all modules that include this file.
17 
18  It is just a forward-declaration file, and is intended to replace several
19  such files. One still needs to include the related header files for these
20  types to be complete.
21 
22  */
23 
24 #include <vector>
25 #include <functional> // for |std::less|
26 
27 #include "constants.h"
28 
29 // |ndebug_use| can be used to ensure variables in assert statements are "used"
30 #ifdef NDEBUG
31 #define ndebug_use(v) static_cast<void>(v)
32 #else
33 #define ndebug_use(v)
34 #endif
35 
36 /******** forward type declarations ******************************************/
37 
38 namespace atlas {
39 
40 /* We begin with copying the contents of the *_fwd.h files in the utilities
41  subdirectory. We justify this abject duplication of information by the fact
42  that it avoids opening many very short files many times during
43  compitlation. Any *_fwd.h files in the structure and gkmod subirectories
44  were simply replaced by this file, avoiding duplication, but the utilities
45  modules have the ambition of being reusable independently of the rest of
46  the Atlas library. In fact this file should always be included in any Atlas
47  header file other than from the utilitites subdierectory, and alway before
48  any header files from that subdirectory, so the definitions here will be
49  the only ones seen when compiling the Atlas library.
50  */
51  namespace set {
52  typedef size_t Elt;
53  typedef std::vector<Elt> EltList;
54  }
55 
56  namespace bitset {
57  template<size_t n> class BitSet;
58  }
59  using bitset::BitSet;
60  typedef BitSet<constants::RANK_MAX> RankFlags;
61  typedef BitSet<2*constants::RANK_MAX> TwoRankFlags;
62  typedef std::vector<RankFlags> RankFlagsList;
63 
64  namespace bitmap { class BitMap; }
65  using bitmap::BitMap;
66 
67  namespace arithmetic {
68  typedef long long int Numer_t;
69  typedef unsigned long long int Denom_t;
70  class Rational;
71  class Split_integer;
72  }
74  typedef std::vector<Rational> RationalList;
76 
77  namespace matrix {
78  template<typename C> class Vector;
79  template<typename C> class Matrix_base;
80  template<typename C> class Matrix;
81  template<typename C> class PID_Matrix;
82  }
83  namespace ratvec { template<typename C> class RationalVector; }
84 
85  namespace permutations { struct Permutation; }
87 
88  namespace partition {
89  class Partition;
90  class PartitionIterator;
91  }
93 
94  namespace poset {
95  class Poset;
96  typedef std::pair<set::Elt,set::Elt> Link;
97  }
98  using poset::Poset;
99 
100  namespace graph {
101  typedef set::Elt Vertex;
102  typedef std::vector<Vertex> VertexList;
103  typedef Vertex Edge;
104  typedef std::vector<Edge> EdgeList;
105  class OrientedGraph;
106  }
107  using graph::OrientedGraph;
108 
109  namespace hashtable{
110  template <class Entry, typename Number> class HashTable;
111  }
112  using hashtable::HashTable;
113 
114  namespace free_abelian {
115  template<typename T, typename C=long int, typename Compare=std::less<T> >
116  struct Free_Abelian;
117  }
119 
120  namespace polynomials {
121  template<typename C> class Polynomial;
122  template<typename C> class Safe_Poly;
123  typedef size_t Degree; // exponent range; not stored.
124  }
126  namespace size {
127  template<typename C> class SizeType;
128  typedef signed char BaseType;
129  typedef unsigned char UnsignedBaseType;
131  }
132 
133 // we should now refrain from subsequently reading the original forward files
134 #define SET_H
135 #define BITSET_FWD_H
136 #define BITMAP_FWD_H
137 #define ARITHMETIC_FWD_H
138 #define MATRIX_FWD_H
139 #define RATVEC_FWD_H
140 #define PERMUTATIONS_FWD_H
141 #define PARTITIONS_FWD_H
142 #define POSET_FWD_H
143 #define HASHTABLE_FWD_H
144 #define FREE_ABELIAN_FWD_H
145 #define POLYNOMIALS_FWD_H
146 #define SIZE_FWD_H
147 
148  // interpetationless terminology
151  typedef std::vector<int_Vector> int_VectorList;
152 
153  // when related to a root system, these alternatives can be used
154  typedef int_Vector Weight;
155  typedef int_Vector Coweight;
159  typedef int_Matrix WeightInvolution;
160  typedef int_Matrix CoweightInvolution;
161 
162  typedef std::vector<Weight> WeightList;
163  typedef std::vector<Weight> CoweightList;
164  typedef std::vector<RatWeight> RatWeightList;
165 
166  // more generic lattice-ralated terms
167  typedef int LatticeCoeff; // the instance type of |Vector| and |Matrix|
168  typedef std::vector<LatticeCoeff> CoeffList; // no vector arithmetic here
170  typedef std::vector<LatticeElt> latticeEltList;
172 
173  namespace bitvector {
174  template<size_t> class BitVector;
175  template<size_t> class BitVectorList;
176  template<size_t> class BitMatrix;
177  }
178  using bitvector::BitVector;
180  using bitvector::BitMatrix;
181  typedef BitVector<constants::RANK_MAX> SmallBitVector;
182  typedef BitVectorList<constants::RANK_MAX> SmallBitVectorList;
183  typedef BitVector<constants::RANK_MAX+1> BinaryEquation;
184  typedef BitVectorList<constants::RANK_MAX+1> BinaryEquationList;
185  typedef BitMatrix<constants::RANK_MAX> BinaryMap;
186 
187  namespace subquotient {
188  template<size_t dim> class Subspace;
189  template<size_t dim> class Subquotient;
190  }
193 
194  namespace lietype {
195  struct SimpleLieType;
196  struct LieType;
197  struct InnerClassType;
198  struct Layout;
199  typedef char TypeLetter;
200  }
202  using lietype::LieType;
204 
205  namespace prerootdata { class PreRootDatum; }
207 
208  namespace rootdata {
209  class RootSystem;
210  class RootDatum;
211  typedef int_Vector Root;
212  typedef WeightList::const_iterator WRootIterator;
213  }
214  using rootdata::RootSystem;
215  using rootdata::RootDatum;
216  typedef unsigned short RootNbr;
217  typedef std::vector<RootNbr> RootNbrList;
219 
220  namespace dynkin { class DynkinDiagram; }
221  using dynkin::DynkinDiagram;
222 
223  namespace weyl {
224  class Twist; // diagram automorphism (in practice always an involution)
225  typedef Twist WeylInterface; // no automorphism, but same implementation
226  typedef unsigned char Generator; // index of simple root / simple reflection
227  struct WeylWord : public std::vector<Generator> { }; // in weyl namesace
228 
229  class WeylElt;
230  class WeylGroup;
232 
233  typedef WeylElt TwistedInvolution;
234  typedef std::vector<WeylElt> WeylEltList;
235  typedef std::vector<TwistedInvolution> TwistedInvolutionList;
236  struct TI_Entry; // for |TwistedInvolution|s in hash tables
237 
238  typedef std::vector<signed char> InvolutionWord;
239  }
240  using weyl::WeylWord;
241  using weyl::WeylElt;
242  using weyl::WeylGroup;
245  using weyl::WeylEltList;
247 
248  namespace y_values {
249  class TorusElement;
250  struct y_entry;
251  }
253  using y_values::y_entry;
254 
255  namespace tits {
256  typedef SmallBitVector TorusPart;
257  class GlobalTitsElement;
258  class GlobalTitsGroup;
259  class SubTitsGroup;
260  class TitsElt;
261  class TitsGroup;
262  struct TE_Entry;
263  class TitsCoset;
264  class EnrichedTitsGroup;
265  }
266  using tits::TorusPart;
268  using tits::GlobalTitsGroup;
269  using tits::TitsElt;
270  using tits::TitsGroup;
271  using tits::TitsCoset;
272 
273  namespace involutions {
274  class InvolutionData;
275  class InvolutionTable;
276  class Cartan_orbit;
277  class Cartan_orbits;
278  }
281  typedef unsigned int InvolutionNbr;
284 
285  namespace gradings {
286  class Status;
287  struct GradingCompare;
288  }
289  typedef RankFlags Grading;
290  typedef std::vector<Grading> GradingList;
291 
292  namespace tori { class RealTorus; }
293 
294  namespace topology { class Connectivity; }
295 
296  namespace subsystem {class SubSystem; class SubSystemWithGroup; }
297  using subsystem::SubSystem;
299 
300 
301  typedef unsigned short CartanNbr; // index of Cartan class
302  typedef unsigned short RealFormNbr; // index used in |InnerClass|
303  typedef std::vector<RealFormNbr> RealFormNbrList;
304 
305  namespace cartanclass {
306  class Fiber;
307  class CartanClass;
308  typedef SmallBitVector FiberElt; // element of the fiber group
309  typedef SmallBitVector AdjointFiberElt; // element of adjoint fiber(-group)
310  typedef unsigned short fiber_orbit; // # of W_imag orbit in fiber group
311  typedef unsigned short adjoint_fiber_orbit; // same for adjoint fiber group
312  typedef unsigned short square_class; // identifies a class of real forms
313  typedef std::pair<fiber_orbit,square_class> StrongRealFormRep;
314  }
315  using cartanclass::Fiber;
317 
318  namespace innerclass { class InnerClass; }
320 
321  namespace realredgp { class RealReductiveGroup; }
323 
324  namespace bruhat { class BruhatOrder; }
325  using bruhat::BruhatOrder;
326 
327  namespace kgb {
328  class KGB_base;
329  struct KGB_elt_entry;
330  class global_KGB;
331  class KGB;
332  typedef RankFlags DescentSet;
333  class KGP;
334  }
335  using kgb::KGB_base;
336  using kgb::KGB_elt_entry;
337  using kgb::global_KGB;
338  using kgb::KGB;
339  typedef unsigned int KGBElt;
340  typedef std::vector<KGBElt> KGBEltList;
341 
342  typedef std::pair<KGBElt,KGBElt> KGBEltPair;
343  typedef std::vector<KGBEltPair> KGBEltPairList;
344 
345  using kgb::DescentSet;
346  static const KGBElt UndefKGB = ~0u;
347 
348  typedef RankFlags Parabolic; // set of generators defining parabolic subgroup
349  typedef unsigned int KGPElt;
350 
351  namespace descents { class DescentStatus; }
353  typedef std::vector<DescentStatus> DescentStatusList;
354 
355  namespace blocks {
356  class ext_gen;
357  class Block_base;
358  class Block;
359  class param_block;
360  class non_integral_block;
361  }
362  using blocks::ext_gen;
363  using blocks::Block_base;
364  using blocks::Block;
365  using blocks::param_block;
367  typedef unsigned int BlockElt;
368  typedef std::vector<BlockElt> BlockEltList;
369  typedef std::pair<BlockElt,BlockElt> BlockEltPair;
370  typedef std::vector<BlockEltPair> BlockEltPairList;
371  static const BlockElt UndefBlock = ~0u;
372 
373  namespace klsupport { class KLSupport; }
374  namespace wgraph {
375  class WGraph;
377  typedef std::vector<unsigned short> WCoeffList;
378  }
379  namespace kl {
380  class KLContext;
381  typedef unsigned int KLCoeff;
383  typedef unsigned int KLIndex; // $<2^{32}$ distinct polynomials for $E_8$!
384  typedef KLCoeff MuCoeff;
385  typedef std::vector<KLPol> KLStore;
386  typedef KLStore::const_reference KLPolRef;
387  typedef std::vector<KLIndex> KLRow;
388  typedef std::vector<BlockElt> PrimitiveRow;
389  }
390  using kl::KLCoeff;
391  using kl::KLPol;
392 
393  namespace standardrepk {
394  class StandardRepK; // standard representation restricted to K
395  typedef std::pair <Weight,RankFlags> HCParam; // free part wrt rho, torsion
396  typedef Free_Abelian<StandardRepK> Char;// linear combination
397  typedef std::pair<StandardRepK,Char> CharForm;
398  typedef std::pair<Weight,TitsElt> RawRep;
399  typedef Free_Abelian<RawRep> RawChar;
400  typedef Free_Abelian<StandardRepK,Polynomial<int> > q_Char;
401  typedef std::pair<StandardRepK,q_Char> q_CharForm;// $q$-$K$-type formula
402  typedef Free_Abelian<RawRep,Polynomial<int> >Raw_q_Char;
403  typedef unsigned int seq_no; // sequence number of stored standard rep|K
404  typedef unsigned int level; // unsigned LatticeCoeff
405  struct Cartan_info;
406  struct bitset_entry;
407  class SRK_context;
408  class graded_compare;// utility class for comparing by degree first
409  class KhatContext;
410  class HechtSchmid; // Hecht-Schmid identity
411  class PSalgebra; // parabolic subalgebra
412  }
415 
416  namespace repr {
417  class StandardRepr; // triple $(x,\lambda,\gamma)$
418  class Rep_context; // support class for interpreting |StandardRepr|
419  class Rep_table; // storage class for |StandardRepr| compuations
420  }
421  using repr::StandardRepr;
422  using repr::Rep_context;
423  using repr::Rep_table;
424 
425  namespace output { class FormNumberMap; } // maps internals to names
426  namespace output { class Interface; } // a pair of the above
427  namespace realweyl {
428  class RealWeyl; // for computing real Weyl groups
429  class RealWeylGenerators;
430  struct PermutationGenerators;
431  }
432 
433  namespace input {
434  class InputBuffer;
435 #ifndef NREADLINE
436  class HistoryBuffer;
437 #else
438  typedef InputBuffer HistoryBuffer;
439 #endif
440  }
441 
442 
443 } // |namespace atlas|
444 
445 #endif
Definition: y_values.h:39
unsigned int InvolutionNbr
Definition: Atlas.h:281
Definition: output.h:74
WeylElt TwistedInvolution
Definition: Atlas.h:231
Polynomials with coefficients in |C|.
Definition: Atlas.h:121
unsigned short square_class
Definition: Atlas.h:312
size_t Elt
Definition: Atlas.h:52
Represents a Weyl group for the purpose of manipulating its elements.
Definition: weyl.h:430
matrix::Vector< int > int_Vector
Definition: Atlas.h:149
Definition: dynkin.h:79
BitVector< constants::RANK_MAX > SmallBitVector
Definition: Atlas.h:181
Definition: kl.h:49
std::vector< RealFormNbr > RealFormNbrList
Definition: Atlas.h:303
char TypeLetter
Definition: Atlas.h:198
unsigned long size
Definition: testprint.cpp:46
matrix::PID_Matrix< LatticeCoeff > LatticeMatrix
Definition: Atlas.h:171
Definition: partition.h:51
Definition: lietype.h:92
Definition: standardrepk.h:583
Definition: klsupport.h:31
std::pair< BlockElt, BlockElt > BlockEltPair
Definition: Atlas.h:369
Definition: Poincare.cpp:13
Definition: tits.h:145
Definition: blocks.h:362
subquotient::Subspace< constants::RANK_MAX > SmallSubspace
Definition: Atlas.h:191
Definition: Atlas.h:79
Twist WeylInterface
Definition: Atlas.h:224
Definition: realredgp.h:41
Definition: blocks.h:69
Definition: Atlas.h:189
Definition: arithmetic.h:54
Represents the restriction to $K$ of a (coherently) continued standard Harish-Chandra module...
Definition: standardrepk.h:140
matrix::Vector< arithmetic::Numer_t > Ratvec_Numer_t
Definition: Atlas.h:158
BitSet< constants::RANK_MAX > RankFlags
Definition: Atlas.h:60
RankFlags DescentSet
Definition: Atlas.h:331
Definition: Atlas.h:176
unsigned short adjoint_fiber_orbit
Definition: Atlas.h:311
Definition: tits.h:66
std::vector< Rational > RationalList
Definition: Atlas.h:74
Definition: involutions.h:44
std::vector< WeylElt > WeylEltList
Definition: Atlas.h:234
std::pair< StandardRepK, Char > CharForm
Definition: Atlas.h:397
Definition: tits.h:628
std::pair< StandardRepK, q_Char > q_CharForm
Definition: Atlas.h:401
Element of a Weyl group.
Definition: weyl.h:88
std::vector< RatWeight > RatWeightList
Definition: Atlas.h:164
set::Elt Vertex
Definition: Atlas.h:101
const BlockElt UndefBlock
Definition: KLread.cpp:121
Free_Abelian< StandardRepK > Char
Definition: Atlas.h:396
Definition: involutions.h:89
int_Vector Root
Definition: Atlas.h:210
Set of n bits.
Definition: Atlas.h:57
Definition: permutations.h:34
Definition: subsystem.h:107
std::vector< KLIndex > KLRow
Definition: Atlas.h:387
Definition: cartanclass.h:98
signed char BaseType
Definition: Atlas.h:127
Definition: kgb.h:235
Definition: standardrepk.h:231
std::vector< Grading > GradingList
Definition: Atlas.h:290
unsigned int KLCoeff
Definition: Atlas.h:380
std::vector< signed char > InvolutionWord
Definition: Atlas.h:236
Free_Abelian< RawRep, Polynomial< int > > Raw_q_Char
Definition: Atlas.h:402
Definition: standardrepk.h:250
polynomials::Safe_Poly< KLCoeff > KLPol
Definition: Atlas.h:382
Definition: Atlas.h:116
std::vector< BlockElt > PrimitiveRow
Definition: Atlas.h:388
Definition: lietype.h:108
unsigned int level
Definition: Atlas.h:404
std::vector< int_Vector > int_VectorList
Definition: Atlas.h:151
Definition: input.h:49
Vertex Edge
Definition: Atlas.h:103
Definition: Atlas.h:174
Definition: kgp.h:44
int_Vector Weight
Definition: Atlas.h:154
std::vector< unsigned short > WCoeffList
Definition: Atlas.h:376
int_Matrix CoweightInvolution
Definition: Atlas.h:160
Definition: kgb.h:217
Definition: lietype.h:123
Definition: weyl.h:659
Definition: wgraph.h:106
Definition: y_values.h:111
std::vector< KLPol > KLStore
Definition: Atlas.h:385
Definition: repr.h:186
Definition: partition.h:176
Free_Abelian< RawRep > RawChar
Definition: Atlas.h:399
BitVector< constants::RANK_MAX+1 > BinaryEquation
Definition: Atlas.h:183
std::vector< DescentStatus > DescentStatusList
Definition: Atlas.h:353
Definition: Atlas.h:175
Definition: rootdata.h:75
Definition: prerootdata.h:48
Definition: standardrepk.h:406
std::vector< KGBEltPair > KGBEltPairList
Definition: Atlas.h:343
std::vector< RankFlags > RankFlagsList
Definition: Atlas.h:62
Based root datum for a complex reductive group.
Definition: rootdata.h:296
std::pair< KGBElt, KGBElt > KGBEltPair
Definition: Atlas.h:342
BitSet< 2 *constants::RANK_MAX > TwoRankFlags
Definition: Atlas.h:61
std::vector< Weight > WeightList
Definition: Atlas.h:162
Intended to represent the Bruhat order on K orbits on G/B, or on a block of representations.
Definition: bruhat.h:37
Definition: Atlas.h:227
Definition: standardrepk.h:423
BitVectorList< constants::RANK_MAX > SmallBitVectorList
Definition: Atlas.h:182
Definition: kgb.h:288
Describes the descent status of each simple root for a single representation.
Definition: descents.h:45
void output(text_pointer)
Definition: ctangle.c:342
Definition: Atlas.h:122
unsigned int KGBElt
Definition: Atlas.h:339
Definition: tits.h:318
int_Vector Coweight
Definition: Atlas.h:155
Definition: gradings.h:53
Definition: weyl.h:780
Definition: graph.h:27
std::pair< Weight, TitsElt > RawRep
Definition: Atlas.h:398
Definition: gradings.h:127
A mapping between one interpretation of Generators and another.
Definition: weyl.h:53
Definition: tits.h:739
Free_Abelian< StandardRepK, Polynomial< int > > q_Char
Definition: Atlas.h:400
Definition: output.h:102
unsigned int seq_no
Definition: Atlas.h:403
std::vector< Edge > EdgeList
Definition: Atlas.h:104
SmallBitVector AdjointFiberElt
Definition: Atlas.h:309
BitVectorList< constants::RANK_MAX+1 > BinaryEquationList
Definition: Atlas.h:184
bitmap::BitMap RootNbrSet
Definition: Atlas.h:218
unsigned long long int Denom_t
Definition: Atlas.h:69
Represents a poset by the matrix of order relations.
Definition: poset.h:39
unsigned short RealFormNbr
Definition: Atlas.h:302
Definition: Atlas.h:78
Definition: Atlas.h:188
std::vector< TwistedInvolution > TwistedInvolutionList
Definition: Atlas.h:235
unsigned short CartanNbr
Definition: Atlas.h:301
matrix::Vector< LatticeCoeff > LatticeElt
Definition: Atlas.h:169
long long int Numer_t
Definition: Atlas.h:68
int_Matrix WeightInvolution
Definition: Atlas.h:159
Definition: Atlas.h:110
Definition: topology.h:43
size_t Degree
Definition: Atlas.h:122
Definition: wgraph.h:44
int LatticeCoeff
Definition: Atlas.h:167
Definition: repr.h:89
Definition: standardrepk.h:560
Definition: repr.h:58
Definition: realweyl.h:183
Definition: blocks.h:315
std::vector< Weight > CoweightList
Definition: Atlas.h:163
std::vector< BlockEltPair > BlockEltPairList
Definition: Atlas.h:370
Definition: lietype.h:78
unsigned char UnsignedBaseType
Definition: Atlas.h:129
Definition: tits.h:442
Represents a block of representations of an inner form of G.
Definition: blocks.h:236
ullong KLIndex
Definition: KLread.cpp:16
Definition: input.h:79
Definition: blocks.h:51
per Cartan class information for handling |StandardRepK| values
Definition: standardrepk.h:194
subquotient::Subquotient< constants::RANK_MAX > SmallSubquotient
Definition: Atlas.h:192
Definition: Atlas.h:38
RankFlags Parabolic
Definition: Atlas.h:348
std::pair< Weight, RankFlags > HCParam
Definition: Atlas.h:394
KLCoeff MuCoeff
Definition: Atlas.h:384
std::vector< Vertex > VertexList
Definition: Atlas.h:102
std::vector< Elt > EltList
Definition: Atlas.h:53
Definition: involutions.h:226
Container of a large (more than twice the machine word size) set of bits.
Definition: bitmap.h:52
Element of lattice tensored with rational numbers.
Definition: Atlas.h:83
BitMatrix< constants::RANK_MAX > BinaryMap
Definition: Atlas.h:185
WeightList::const_iterator WRootIterator
Definition: Atlas.h:212
unsigned short RootNbr
Definition: Atlas.h:216
ratvec::RationalVector< arithmetic::Numer_t > RatCoweight
Definition: Atlas.h:157
SmallBitVector TorusPart
Definition: Atlas.h:256
unsigned short fiber_orbit
Definition: Atlas.h:310
unsigned char Generator
Definition: Atlas.h:226
Definition: arithmetic.h:112
unsigned int BlockElt
Definition: Atlas.h:367
RankFlags Grading
Definition: Atlas.h:289
std::vector< RootNbr > RootNbrList
Definition: Atlas.h:217
Definition: cartanclass.h:488
matrix::PID_Matrix< int > int_Matrix
Definition: Atlas.h:150
Definition: realweyl.h:36
std::vector< BlockElt > BlockEltList
Definition: Atlas.h:368
Definition: tits.h:659
SmallBitVector FiberElt
Definition: Atlas.h:307
std::vector< LatticeCoeff > CoeffList
Definition: Atlas.h:168
Definition: involutions.h:241
Represents a torus defined over R.
Definition: tori.h:82
Definition: subsystem.h:37
std::pair< fiber_orbit, square_class > StrongRealFormRep
Definition: Atlas.h:313
Definition: Atlas.h:81
Stores a positive integer as product of prime powers, using the first PRIMES_MAX primes.
Definition: Atlas.h:127
std::vector< LatticeElt > latticeEltList
Definition: Atlas.h:170
Definition: innerclass.h:171
KLStore::const_reference KLPolRef
Definition: Atlas.h:386
ratvec::RationalVector< arithmetic::Numer_t > RatWeight
Definition: Atlas.h:156
std::pair< set::Elt, set::Elt > Link
Definition: Atlas.h:95
Definition: kgb.h:55
Definition: Atlas.h:80
std::vector< KGBElt > KGBEltList
Definition: Atlas.h:340
unsigned int KGPElt
Definition: Atlas.h:349
SizeType< BaseType > Size
Definition: Atlas.h:130