MultiIndex< T > Class Template Reference

Implements a container class for multi-indexed objects with an arbitrary number of indices. More...

#include <MultiIndex.h>

Classes
class	const_noconst_iterator
	MultiIndex container iterator. More...

Public Types
typedef T	value_type
	container related types and categories More...
typedef std::vector< unsigned int >	size_type
using	iterator = const_noconst_iterator< false >
using	const_iterator = const_noconst_iterator< true >

Public Member Functions
	MultiIndex (const size_type &shape)
	construct zero initialized container of a given shape More...
	MultiIndex (const size_type &shape, const std::vector< T > &data)
	construct container of a given shape initialized from a flat data blob More...
const size_type &	size () const
	container size as dim dimensional vector More...
unsigned int	dim () const
	dimension of the container More...
unsigned int	nEntries () const
	total number of values stored in the container More...
std::vector< T >	getRawData () const
	get the raw data vector More...
void	resize (const size_type &shape)
	Resize container. Must keep dimensionality constant. More...
void	assign (const size_type &shape, T value)
	Reshape container arbitrarily and initialize with value. More...
unsigned int	flatIndex (const size_type &indices) const
	compute the flat index for a size_type index More...
T &	operator() (const size_type &indices)
	element access operators More...
const T &	operator() (const size_type &indices) const
T &	operator[] (unsigned int j)
	direct data access via bracket operator More...
const T &	operator[] (unsigned int j) const
T &	at (unsigned int j)
MultiIndex< T >	slice (unsigned int dimension, unsigned int index) const
	accesses a slice of the multi index object More...
MultiIndex< T >	slice (size_type dimension, size_type index) const
unsigned int	stride (unsigned int j) const
	access the stride More...
const size_type &	stride () const
void	dataStore (std::ostream &stream, void *context)
	Implement loadHelper and storeHelper for easier data (de)serialization. More...
void	dataLoad (std::istream &stream, void *context)
iterator	begin ()
	iterators for begin and end of this container More...
iterator	end ()
const_iterator	begin () const
const_iterator	end () const

Protected Member Functions
void	findIndexVector (unsigned int flat_index, size_type &indices) const
	given a flat index computes the vector of indices i0, i1, i2, ... More...

Protected Attributes
size_type	_shape
	the size along each index More...
unsigned int	_dim
	the number of dimensions TODO: get rid of this -> _shape.size() More...
unsigned int	_nentries
	the number of entries TODO: get rid of this -> _data.size() More...
size_type	_stride
	stride for each index, e.g. if you know {i, j, k} -> flat_index, {i, j + 1, k} = flat_index + stride[1] More...
std::vector< T >	_data
	the data unrolled into a vector More...

Private Member Functions
void	buildAccumulatedShape ()
	build accumulated shape vector for flat index calculation More...
void	reshape (const size_type &shape)
	change the container shape and reset meta data More...

Detailed Description

template<class T>
class MultiIndex< T >

Implements a container class for multi-indexed objects with an arbitrary number of indices.

Definition at line 22 of file MultiIndex.h.

Member Typedef Documentation

const_iterator

template<class T>

using MultiIndex< T >::const_iterator = const_noconst_iterator<true>

Definition at line 33 of file MultiIndex.h.

iterator

template<class T>

using MultiIndex< T >::iterator = const_noconst_iterator<false>

Definition at line 32 of file MultiIndex.h.

size_type

template<class T>

typedef std::vector<unsigned int> MultiIndex< T >::size_type

Definition at line 31 of file MultiIndex.h.

value_type

template<class T>

typedef T MultiIndex< T >::value_type

container related types and categories

Definition at line 27 of file MultiIndex.h.

Constructor & Destructor Documentation

MultiIndex() [1/2]

template<class T >

MultiIndex< T >::MultiIndex

(

const size_type &

shape

)

construct zero initialized container of a given shape

Definition at line 249 of file MultiIndex.h.

{
  reshape(shape);
  _data.resize(_nentries);
}

MultiIndex() [2/2]

template<class T>

MultiIndex< T >::MultiIndex	(	const size_type &	shape,
		const std::vector< T > &	data
	)

construct container of a given shape initialized from a flat data blob

Definition at line 256 of file MultiIndex.h.

{
  reshape(shape);

  if (data.size() != _nentries)
    mooseError("shape and data arguments' sizes are inconsistent.");
  _data = data;
}

Member Function Documentation

assign()

template<class T>

void MultiIndex< T >::assign	(	const size_type &	shape,
		T	value
	)

Reshape container arbitrarily and initialize with value.

Definition at line 397 of file MultiIndex.h.

{
  reshape(shape);
  _data.assign(_nentries, value);
}

at()

template<class T>

T& MultiIndex< T >::at ( unsigned int  j )

inline

Definition at line 50 of file MultiIndex.h.

{ return _data.at(j); }

begin() [1/2]

template<class T>

iterator MultiIndex< T >::begin ( )

inline

iterators for begin and end of this container

Definition at line 87 of file MultiIndex.h.

Referenced by MultiIndex< Real >::slice().

{ return const_noconst_iterator<false>(*this, 0); }

begin() [2/2]

template<class T>

const_iterator MultiIndex< T >::begin ( ) const

inline

Definition at line 89 of file MultiIndex.h.

{ return const_noconst_iterator<true>(*this, 0); }

buildAccumulatedShape()

template<class T >

void MultiIndex< T >::buildAccumulatedShape ( )

private

build accumulated shape vector for flat index calculation

Definition at line 439 of file MultiIndex.h.

{
  // TODO: simplify - this is needlessly complicated - can be done in a single loop
  _stride.resize(_dim);
  for (unsigned int d = 0; d < _dim; ++d)
  {
    unsigned int k = 1;
    for (unsigned int j = d + 1; j < _dim; ++j)
      k *= _shape[j];
    _stride[d] = k;
  }
}

dataLoad()

template<class T >

void MultiIndex< T >::dataLoad	(	std::istream &	stream,
		void *	context
	)

Definition at line 413 of file MultiIndex.h.

Referenced by dataLoad().

{
  ::dataLoad(stream, _shape, context);
  ::dataLoad(stream, _data, context);
  _dim = _shape.size();
  _nentries = _data.size();
  buildAccumulatedShape();
}

dataStore()

template<class T >

void MultiIndex< T >::dataStore	(	std::ostream &	stream,
		void *	context
	)

Implement loadHelper and storeHelper for easier data (de)serialization.

Definition at line 405 of file MultiIndex.h.

Referenced by dataStore().

{
  ::dataStore(stream, _shape, context);
  ::dataStore(stream, _data, context);
}

dim()

template<class T>

unsigned int MultiIndex< T >::dim ( ) const

inline

dimension of the container

Definition at line 62 of file MultiIndex.h.

Referenced by MultiDimensionalInterpolationTempl< T >::setData().

{ return _shape.size(); }

end() [1/2]

template<class T>

iterator MultiIndex< T >::end ( )

inline

Definition at line 88 of file MultiIndex.h.

{ return const_noconst_iterator<false>(*this, _nentries); }

end() [2/2]

template<class T>

const_iterator MultiIndex< T >::end ( ) const

inline

Definition at line 90 of file MultiIndex.h.

{ return const_noconst_iterator<true>(*this, _nentries); }

findIndexVector()

template<class T>

void MultiIndex< T >::findIndexVector ( unsigned int  flat_index, size_type &  indices  ) const

protected

given a flat index computes the vector of indices i0, i1, i2, ...

Definition at line 424 of file MultiIndex.h.

{
  indices.resize(_dim);
  for (unsigned int d = 0; d < _dim; ++d)
  {
    unsigned int i = flat_index / _stride[d];
    indices[d] = i;
    flat_index -= i * _stride[d];
  }
}

flatIndex()

template<class T >

unsigned int MultiIndex< T >::flatIndex

(

const size_type &

indices

)

const

compute the flat index for a size_type index

Definition at line 477 of file MultiIndex.h.

{
  mooseAssert(indices.size() == _dim,
              "Indices vector has wrong size. size=" << indices.size() << " vs. dim=" << _dim);
#if DEBUG
  for (unsigned int j = 0; j < indices.size(); ++j)
    if (indices[j] >= _shape[j])
      mooseError("Indices vector at entry ", j, " is ", indices[j], " vs. shape ", _shape[j]);
#endif // DEBUG

  // implement the index
  // index = i_M + i_{M-1} * I_M + i_{M-1} * I_M * I_{M-1} ...
  unsigned int index = 0;
  for (unsigned int d = 0; d < _dim; ++d)
    index += indices[d] * _stride[d];

  return index;
}

getRawData()

template<class T>

std::vector<T> MultiIndex< T >::getRawData ( ) const

inline

get the raw data vector

Definition at line 68 of file MultiIndex.h.

{ return _data; }

nEntries()

template<class T>

unsigned int MultiIndex< T >::nEntries ( ) const

inline

total number of values stored in the container

Definition at line 65 of file MultiIndex.h.

{ return _nentries; }

operator()() [1/2]

template<class T >

T & MultiIndex< T >::operator()

(

const size_type &

indices

)

element access operators

Definition at line 267 of file MultiIndex.h.

{
  return _data[flatIndex(indices)];
}

operator()() [2/2]

template<class T >

const T & MultiIndex< T >::operator()

(

const size_type &

indices

)

const

Definition at line 274 of file MultiIndex.h.

{
  return _data[flatIndex(indices)];
}

operator[]() [1/2]

template<class T>

T& MultiIndex< T >::operator[] ( unsigned int  j )

inline

direct data access via bracket operator

Definition at line 48 of file MultiIndex.h.

{ return _data[j]; }

operator[]() [2/2]

template<class T>

const T& MultiIndex< T >::operator[] ( unsigned int  j ) const

inline

Definition at line 49 of file MultiIndex.h.

{ return _data[j]; }

reshape()

template<class T >

void MultiIndex< T >::reshape ( const size_type &  shape )

private

change the container shape and reset meta data

Definition at line 454 of file MultiIndex.h.

{
  if (shape.size() == 0)
  {
    _shape = {};
    _dim = 0;
    _stride = {};
    _nentries = 0;
    return;
  }

  _shape = shape;
  _dim = shape.size();

  _nentries = 1;
  for (unsigned int d = 0; d < _dim; ++d)
    _nentries *= _shape[d];

  buildAccumulatedShape();
}

resize()

template<class T >

void MultiIndex< T >::resize

(

const size_type &

shape

)

Resize container. Must keep dimensionality constant.

Definition at line 345 of file MultiIndex.h.

Referenced by MultiIndex< Real >::findIndexVector(), and MultiDimensionalInterpolationTempl< T >::linearSearch().

{
  if (shape.size() != _shape.size())
    mooseError("resize cannot change the dimensionality of MultiIndex.");

  // first copy the old shape and data
  size_type old_shape = _shape;
  size_type old_stride = _stride;
  std::vector<T> old_data = _data;

  // reset _shape & recompute meta data
  reshape(shape);

  // fill in _data to all possible indices
  _data.assign(_nentries, T(0));
  for (unsigned int j = 0; j < _nentries; ++j)
  {
    size_type indices;
    findIndexVector(j, indices);

    // check if indices existed in the old version of _data
    bool existed_in_old = true;
    for (unsigned int d = 0; d < _dim; ++d)
      if (indices[d] >= old_shape[d])
      {
        existed_in_old = false;
        break;
      }

    // find the corresponding old_j
    if (existed_in_old)
    {
      unsigned int old_j = 0;
      for (unsigned int d = 0; d < _dim; ++d)
        old_j += indices[d] * old_stride[d];

      // finally set the data entry
      _data[j] = old_data[old_j];
    }
  }
}

size()

template<class T>

const size_type& MultiIndex< T >::size ( ) const

inline

container size as dim dimensional vector

Definition at line 59 of file MultiIndex.h.

Referenced by MultiDimensionalInterpolationTempl< T >::errorCheck(), and MultiDimensionalInterpolationTempl< T >::setData().

{ return _shape; }

slice() [1/2]

template<class T >

MultiIndex< T > MultiIndex< T >::slice	(	unsigned int	dimension,
		unsigned int	index
	)		const

accesses a slice of the multi index object

Definition at line 281 of file MultiIndex.h.

Referenced by MultiDimensionalInterpolationTempl< T >::setData().

{
  size_type dim(1, dimension);
  size_type ind(1, index);
  return slice(dim, ind);
}

slice() [2/2]

template<class T >

MultiIndex< T > MultiIndex< T >::slice	(	size_type	dimension,
		size_type	index
	)		const

Definition at line 290 of file MultiIndex.h.

{
  // input checks
  if (dimension.size() != index.size())
    mooseError("dimension and index must have the same size.");
  if (dimension.size() > _dim - 1)
    mooseError("The result of slice must be at least of dimension 1.");

#if DEBUG
  for (unsigned int d = 0; d < dimension.size(); ++d)
  {
    if (dimension[d] >= _dim)
      mooseError("dimension is set to ", dimension[d], " which is larger than _dim ", _dim);
    if (index[d] >= _shape[dimension[d]])
      mooseError("index= ",
                 index[d],
                 " at dimension=",
                 dimension[d],
                 " is larger than ",
                 _shape[dimension[d]]);
  }
#endif // DEBUG

  // create a MultiIndex object with new dim = dim - dimension.size()
  size_type new_shape;
  for (unsigned int j = 0; j < _dim; ++j)
    if (std::find(dimension.begin(), dimension.end(), j) == dimension.end())
      new_shape.push_back(_shape[j]);
  MultiIndex<T> multi_index = MultiIndex(new_shape);

  // copy the data
  MultiIndex<T>::iterator it = multi_index.begin();
  for (unsigned int n = 0; n < _nentries; ++n)
  {
    size_type indices;
    findIndexVector(n, indices);
    bool addTo = true;
    for (unsigned int d = 0; d < dimension.size(); ++d)
      if (indices[dimension[d]] != index[d])
      {
        addTo = false;
        break;
      }

    if (addTo)
    {
      (*it).second = _data[n];
      ++it;
    }
  }
  return multi_index;
}

stride() [1/2]

template<class T >

unsigned int MultiIndex< T >::stride

(

unsigned int

j

)

const

access the stride

Definition at line 389 of file MultiIndex.h.

Referenced by MultiDimensionalInterpolationTempl< T >::multiLinearInterpolation().

{
  mooseAssert(j < _dim, "Dimension is" << _dim << ", stride(j) called with j = " << j);
  return _stride[j];
}

stride() [2/2]

template<class T>

const size_type& MultiIndex< T >::stride ( ) const

inline

Definition at line 78 of file MultiIndex.h.

{ return _stride; }

Member Data Documentation

_data

template<class T>

std::vector<T> MultiIndex< T >::_data

protected

the data unrolled into a vector

Definition at line 113 of file MultiIndex.h.

Referenced by MultiIndex< Real >::at(), MultiIndex< Real >::getRawData(), and MultiIndex< Real >::operator[]().

_dim

template<class T>

unsigned int MultiIndex< T >::_dim

protected

the number of dimensions TODO: get rid of this -> _shape.size()

Definition at line 104 of file MultiIndex.h.

_nentries

template<class T>

unsigned int MultiIndex< T >::_nentries

protected

the number of entries TODO: get rid of this -> _data.size()

Definition at line 107 of file MultiIndex.h.

Referenced by MultiIndex< Real >::end(), and MultiIndex< Real >::nEntries().

_shape

template<class T>

size_type MultiIndex< T >::_shape

protected

the size along each index

Definition at line 101 of file MultiIndex.h.

Referenced by MultiIndex< Real >::dim(), MultiIndex< T >::const_noconst_iterator< is_const >::operator++(), MultiIndex< T >::const_noconst_iterator< is_const >::operator--(), and MultiIndex< Real >::size().

_stride

template<class T>

size_type MultiIndex< T >::_stride

protected

stride for each index, e.g. if you know {i, j, k} -> flat_index, {i, j + 1, k} = flat_index + stride[1]

Definition at line 110 of file MultiIndex.h.

Referenced by MultiIndex< Real >::stride().

---

The documentation for this class was generated from the following file:

• include/utils/MultiIndex.h