AXOM
Axom provides a robust, flexible software infrastructure for the development of multi-physics applications and computational tools.
axom::slam Namespace Reference

Namespaces

 policies
 
 util
 

Classes

class  BitSet
 A bitset class. More...
 
class  BivariateMap
 A Map for BivariateSet. It associates a constant number of values to every element in a BivariateSet (as determined by StridePolicy). More...
 
class  BivariateSet
 Abstract class that models a set whose elements are indexed by two indices. Each element in a BivariateSet is equivalent to an ordered pair containing a row and column index, similar to indexing in a matrix. More...
 
class  DynamicConstantRelation
 A relation class with constant cardinality that supports adding, removing and modifying set relations. More...
 
class  DynamicMap
 A slam map class that supports adding and removing entries. More...
 
class  DynamicSet
 A Set class that supports dynamically adding and removing set items. More...
 
class  DynamicVariableRelation
 
struct  EmptySetTraits
 
class  FieldRegistry
 Simple container for fields of type DataType w/ minimal error checking. More...
 
class  GenericRangeSet
 Models a set whose elements belong to a contiguous range \( \in [lowerIndex,upperIndex) \). More...
 
class  IteratorBase
 Base class for a random access iterator over positions in a set. More...
 
class  Map
 A Map class that associates a constant number of values to every element in a set. More...
 
class  MapBase
 A base class specifying methods that support operations of a Map, associating value(s) to each element in a Set. MapBase can be used as a base class pointer to a templated Map object. More...
 
class  ModularInt
 This class is a wrapper around an int and encapsulates modular arithmetic with a given modulus. More...
 
class  NotImplementedException
 
class  NullBivariateSet
 A Null BivariateSet class. Same as the NullSet for Set class. More...
 
class  NullSet
 An indexed set (a tuple) of entities in a simulation. More...
 
class  OrderedSet
 Models a set whose elements can be defined as strided offsets of the position, possibly with a level of indirection. More...
 
class  PositionSet
 Alias template for an OrderedSet whose elements belong to a contiguous range \( \in [0,size) \). More...
 
class  ProductSet
 Models a set whose element is the Cartesian product of two sets. The number of elements in this set is the product of the sizes of the two input sets. More...
 
class  RangeSet
 A specialization of GenericRangeSet with stride 1 and no indirection. More...
 
class  Relation
 
class  RelationSet
 Models a Set whose elements are derived from a relation, one element per fromSet and toSet pair in the relation. More...
 
class  Set
 Abstract base class for a Set of entities in a simulation. More...
 
class  StaticRelation
 
class  SubMap
 The SubMap class provides an API to easily traverse a subset of a Map. More...
 

Typedefs

template<typename PosType = slam::DefaultPositionType, typename ElemType = slam::DefaultElementType>
using ArrayIndirectionSet = OrderedSet< PosType, ElemType, policies::RuntimeSize< PosType >, policies::ZeroOffset< PosType >, policies::StrideOne< PosType >, policies::ArrayIndirection< PosType, ElemType > >
 Alias template for an OrderedSet with indirection over an array. More...
 
template<typename PosType = slam::DefaultPositionType, typename ElemType = slam::DefaultElementType>
using VectorIndirectionSet = OrderedSet< PosType, ElemType, policies::RuntimeSize< PosType >, policies::ZeroOffset< PosType >, policies::StrideOne< PosType >, policies::STLVectorIndirection< PosType, ElemType > >
 Alias template for an OrderedSet with indirection over an stl vector. More...
 
using DefaultPositionType = axom::IndexType
 
using DefaultElementType = axom::IndexType
 

Functions

BitSet operator| (const BitSet &lhs, const BitSet &rhs)
 Union operator for two bit sets. More...
 
BitSet operator & (const BitSet &lhs, const BitSet &rhs)
 Intersection operator for two bit sets. More...
 
BitSet operator^ (const BitSet &lhs, const BitSet &rhs)
 Exclusive or (xor) operator for two bit sets. More...
 
BitSet operator- (const BitSet &lhs, const BitSet &rhs)
 Set difference operator for two bit sets. More...
 
template<typename SizePolicy >
ModularInt< SizePolicy > operator+ (const ModularInt< SizePolicy > &zn, const int n)
 
template<typename SizePolicy >
ModularInt< SizePolicy > operator+ (const int n, const ModularInt< SizePolicy > &zn)
 
template<typename SizePolicy >
ModularInt< SizePolicy > operator- (const ModularInt< SizePolicy > &zn, const int n)
 
template<typename SizePolicy >
ModularInt< SizePolicy > operator- (const int n, const ModularInt< SizePolicy > &zn)
 
template<typename SizePolicy >
ModularInt< SizePolicy > operator* (const ModularInt< SizePolicy > &zn, const int n)
 
template<typename SizePolicy >
ModularInt< SizePolicy > operator* (const int n, const ModularInt< SizePolicy > &zn)
 
template<typename P1 , typename E1 , typename P2 , typename E2 >
bool operator== (const Set< P1, E1 > &set1, const Set< P2, E2 > &set2)
 General equality operator for two sets. More...
 
template<typename P1 , typename E1 , typename P2 , typename E2 >
bool operator!= (const Set< P1, E1 > &set1, const Set< P2, E2 > &set2)
 Set inequality operator. More...
 

Typedef Documentation

◆ ArrayIndirectionSet

template<typename PosType = slam::DefaultPositionType, typename ElemType = slam::DefaultElementType>
using axom::slam::ArrayIndirectionSet = typedef OrderedSet<PosType, ElemType, policies::RuntimeSize<PosType>, policies::ZeroOffset<PosType>, policies::StrideOne<PosType>, policies::ArrayIndirection<PosType, ElemType> >

Alias template for an OrderedSet with indirection over an array.

Template Parameters
PosTypeThe position type for indexing into the set
ElemTypeThe type for the set's elements
See also
OrderedSet

◆ VectorIndirectionSet

template<typename PosType = slam::DefaultPositionType, typename ElemType = slam::DefaultElementType>
using axom::slam::VectorIndirectionSet = typedef OrderedSet<PosType, ElemType, policies::RuntimeSize<PosType>, policies::ZeroOffset<PosType>, policies::StrideOne<PosType>, policies::STLVectorIndirection<PosType, ElemType> >

Alias template for an OrderedSet with indirection over an stl vector.

Template Parameters
PosTypeThe position type for indexing into the set
ElemTypeThe type for the set's elements
See also
OrderedSet

◆ DefaultPositionType

◆ DefaultElementType

Function Documentation

◆ operator|()

BitSet axom::slam::operator| ( const BitSet lhs,
const BitSet rhs 
)

Union operator for two bit sets.

Parameters
lhsThe first bitset
rhsThe second bitset
Returns
The union of the two input bitsets, where the i^th bit is set it is set in either lhs or rhs (e.g. b[i] = lhs[i] || rhs[i]).
Precondition
lhs.size() == rhs.size()

◆ operator &()

BitSet axom::slam::operator& ( const BitSet lhs,
const BitSet rhs 
)

Intersection operator for two bit sets.

Parameters
lhsThe first bitset
rhsThe second bitset
Returns
The intersection of the two input bitsets, where the i^th bit is set it is set in both lhs and rhs (e.g. b[i] = lhs[i] && rhs[i]).
Precondition
lhs.size() == rhs.size()

◆ operator^()

BitSet axom::slam::operator^ ( const BitSet lhs,
const BitSet rhs 
)

Exclusive or (xor) operator for two bit sets.

Parameters
lhsThe first bitset
rhsThe second bitset
Returns
The xor of the two input bitsets, where the i^th bit is set it is set in either lhs or rhs but not both (e.g. b[i] = lhs[i] ^ rhs[i]).
Precondition
lhs.size() == rhs.size()

◆ operator-() [1/3]

BitSet axom::slam::operator- ( const BitSet lhs,
const BitSet rhs 
)

Set difference operator for two bit sets.

Parameters
lhsThe first bitset
rhsThe second bitset
Returns
The set difference of the two input bitsets, where the i^th bit is set it is set in lhs and not rhs (e.g. b[i] = lhs[i] && ! rhs[i]).
Precondition
lhs.size() == rhs.size()

◆ operator+() [1/2]

template<typename SizePolicy >
ModularInt<SizePolicy> axom::slam::operator+ ( const ModularInt< SizePolicy > &  zn,
const int  n 
)

◆ operator+() [2/2]

template<typename SizePolicy >
ModularInt<SizePolicy> axom::slam::operator+ ( const int  n,
const ModularInt< SizePolicy > &  zn 
)

◆ operator-() [2/3]

template<typename SizePolicy >
ModularInt<SizePolicy> axom::slam::operator- ( const ModularInt< SizePolicy > &  zn,
const int  n 
)

◆ operator-() [3/3]

template<typename SizePolicy >
ModularInt<SizePolicy> axom::slam::operator- ( const int  n,
const ModularInt< SizePolicy > &  zn 
)

◆ operator*() [1/2]

template<typename SizePolicy >
ModularInt<SizePolicy> axom::slam::operator* ( const ModularInt< SizePolicy > &  zn,
const int  n 
)

◆ operator*() [2/2]

template<typename SizePolicy >
ModularInt<SizePolicy> axom::slam::operator* ( const int  n,
const ModularInt< SizePolicy > &  zn 
)

◆ operator==()

template<typename P1 , typename E1 , typename P2 , typename E2 >
bool axom::slam::operator== ( const Set< P1, E1 > &  set1,
const Set< P2, E2 > &  set2 
)
inline

General equality operator for two sets.

Two sets are considered equal if they have the same number of elements and their ordered indices agree.

References axom::slam::Set< PosType, ElemType >::at(), and axom::slam::Set< PosType, ElemType >::size().

Referenced by axom::slam::NullSet< RelationType::SetPosition, RelationType::SetElement >::empty().

◆ operator!=()

template<typename P1 , typename E1 , typename P2 , typename E2 >
bool axom::slam::operator!= ( const Set< P1, E1 > &  set1,
const Set< P2, E2 > &  set2 
)
inline