dash::LocalMemoryLayout< NumDimensions, Arrangement, IndexType > Class Template Reference

Specifies how local element indices are arranged in a specific number of dimensions. More...

#include <Cartesian.h>

Public Types
typedef IndexType	index_type
typedef SizeType	size_type
typedef std::array< SizeType, NumDimensions >	extents_type
typedef std::integral_constant< dim_t, NumDimensions >	ndim
	The number of dimension in the cartesian space. More...

Public Member Functions
constexpr	LocalMemoryLayout (const SizeSpec< NumDimensions > &sizespec, const DistributionSpec< NumDimensions > &distspec)
	Constructor, creates an instance of LocalMemoryLayout from a SizeSpec and a DistributionSpec of NumDimensions dimensions. More...
constexpr	LocalMemoryLayout (const DistributionSpec< NumDimensions > &distspec)
	Constructor, creates an instance of LocalMemoryLayout with initial extents 0 and a DistributionSpec of NumDimensions dimensions. More...
bool	operator== (const self_t &other) const
	Equality comparison operator. More...
constexpr bool	operator!= (const self_t &other) const
	Inequality comparison operator. More...
template<typename... Args>
void	resize (SizeType arg, Args... args)
	Change the extent of the cartesian space in every dimension. More...
template<typename SizeType_ >
void	resize (std::array< SizeType_, NumDimensions > extents)
	Change the extent of the cartesian space in every dimension. More...
template<typename... Args, MemArrange AtArrangement = Arrangement>
constexpr IndexType	at (IndexType arg, Args... args) const
	Convert the given coordinates to their respective linear index. More...
template<MemArrange AtArrangement = Arrangement, typename OffsetType >
IndexType	at (const std::array< OffsetType, NumDimensions > &point) const
	Convert the given cartesian point to its respective linear index. More...
template<MemArrange AtArrangement = Arrangement, typename OffsetType >
IndexType	at (const std::array< OffsetType, NumDimensions > &point, const ViewSpec_t &viewspec) const
	Convert the given cartesian point to a linear index, respective to the offsets specified in the given ViewSpec. More...
template<MemArrange CoordArrangement = Arrangement>
std::array< IndexType, NumDimensions >	coords (IndexType index) const
	Convert given linear offset (index) to cartesian coordinates. More...
constexpr dim_t	rank () const noexcept
	The number of dimension in the cartesian space with extent greater than 1. More...
template<typename SizeType_ >
void	resize (const std::array< SizeType_, NumDimensions > &extents)
	Change the extent of the cartesian space in every dimension. More...
void	resize (dim_t dim, SizeType extent)
	Change the extent of the cartesian space in the given dimension. More...
constexpr SizeType	size () const noexcept
	The number of discrete elements within the space spanned by the coordinate. More...
constexpr const extents_type &	extents () const noexcept
	Extents of the cartesian space, by dimension. More...
SizeType	extent (dim_t dim) const
	The extent of the cartesian space in the given dimension. More...
template<MemArrange CoordArrangement = Arrangement>
std::array< IndexType, NumDimensions >	coords (IndexType index, const ViewSpec_t &viewspec) const
	Convert given linear offset (index) to cartesian coordinates with respect to a given viewspec. More...
template<dim_t U = NumDimensions>
constexpr std::enable_if<(U > 0), SizeType >::type	x (SizeType offs) const
	Accessor for dimension 1 (x), enabled for dimensionality > 0. More...
template<dim_t U = NumDimensions>
constexpr std::enable_if<(U > 1), SizeType >::type	y (SizeType offs) const
	Accessor for dimension 2 (y), enabled for dimensionality > 1. More...
template<dim_t U = NumDimensions>
constexpr std::enable_if<(U > 2), SizeType >::type	z (SizeType offs) const
	Accessor for dimension 3 (z), enabled for dimensionality > 2. More...

Detailed Description

template<size_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>
class dash::LocalMemoryLayout< NumDimensions, Arrangement, IndexType >

Specifies how local element indices are arranged in a specific number of dimensions.

Behaves like CartesianIndexSpace if distribution is not tiled in any dimension.

Template Parameters

NumDimensions

Number of dimensions

Definition at line 627 of file Cartesian.h.

Member Typedef Documentation

ndim

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

typedef std::integral_constant<dim_t, NumDimensions> dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::ndim

inherited

The number of dimension in the cartesian space.

Definition at line 279 of file Cartesian.h.

Constructor & Destructor Documentation

LocalMemoryLayout() [1/2]

template<size_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

constexpr dash::LocalMemoryLayout< NumDimensions, Arrangement, IndexType >::LocalMemoryLayout ( const SizeSpec< NumDimensions > &  sizespec, const DistributionSpec< NumDimensions > &  distspec  )

inline

Constructor, creates an instance of LocalMemoryLayout from a SizeSpec and a DistributionSpec of NumDimensions dimensions.

Definition at line 644 of file Cartesian.h.

  : parent_t(sizespec),
    _distspec(distspec) {
  }

LocalMemoryLayout() [2/2]

template<size_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

constexpr dash::LocalMemoryLayout< NumDimensions, Arrangement, IndexType >::LocalMemoryLayout ( const DistributionSpec< NumDimensions > &  distspec )

inline

Constructor, creates an instance of LocalMemoryLayout with initial extents 0 and a DistributionSpec of NumDimensions dimensions.

Definition at line 655 of file Cartesian.h.

  : parent_t(SizeSpec<NumDimensions>()),
    _distspec(distspec) {
  }

Member Function Documentation

at() [1/3]

template<size_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

template<typename... Args, MemArrange AtArrangement = Arrangement>

constexpr IndexType dash::LocalMemoryLayout< NumDimensions, Arrangement, IndexType >::at ( IndexType  arg, Args...  args  ) const

inline

Convert the given coordinates to their respective linear index.

Parameters

args	An argument list consisting of the coordinates, ordered by dimension (x, y, z, ...)

Definition at line 714 of file Cartesian.h.

                                         {
    static_assert(
      sizeof...(Args) == NumDimensions-1,
      "Invalid number of arguments");
    return at<AtArrangement>(
             std::array<IndexType, NumDimensions> {
               arg, (IndexType)(args) ... }
           );
  }

at() [2/3]

template<size_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

template<MemArrange AtArrangement = Arrangement, typename OffsetType >

IndexType dash::LocalMemoryLayout< NumDimensions, Arrangement, IndexType >::at ( const std::array< OffsetType, NumDimensions > &  point ) const

inline

Convert the given cartesian point to its respective linear index.

Parameters

point

An array containing the coordinates, ordered by dimension (x, y, z, ...)

Definition at line 734 of file Cartesian.h.

                                                             {
    if (!_distspec.is_tiled()) {
      // Default case, no tiles
      return parent_t::at(point);
    }
    // Tiles in at least one dimension
    // TODO
    DASH_THROW(dash::exception::NotImplemented,
               "CartesianIndexSpace::at(IndexType) not implemented for tiles!");
  }

at() [3/3]

template<size_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

template<MemArrange AtArrangement = Arrangement, typename OffsetType >

IndexType dash::LocalMemoryLayout< NumDimensions, Arrangement, IndexType >::at ( const std::array< OffsetType, NumDimensions > &  point, const ViewSpec_t &  viewspec  ) const

inline

Convert the given cartesian point to a linear index, respective to the offsets specified in the given ViewSpec.

Parameters

point	An array containing the coordinates, ordered by dimension (x, y, z, ...)
viewspec	An instance of ViewSpec to apply to the given point before resolving the linear index.

Definition at line 758 of file Cartesian.h.

                                       {
    std::array<OffsetType, NumDimensions> coords;
    for (auto d = 0; d < NumDimensions; ++d) {
      coords[d] = point[d] + viewspec[d].offset;
    }
    return at(coords);
  }

coords() [1/2]

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

template<MemArrange CoordArrangement = Arrangement>

std::array<IndexType, NumDimensions> dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::coords ( IndexType  index, const ViewSpec_t &  viewspec  ) const

inlineinherited

Convert given linear offset (index) to cartesian coordinates with respect to a given viewspec.

Inverse of at(...).

Definition at line 526 of file Cartesian.h.

  {
    std::array<IndexType, NumDimensions> pos{};
    extents_type offset;
    if (CoordArrangement == ROW_MAJOR)
    {
      offset[NumDimensions-1] = 1;
      for(auto i = NumDimensions-2; i >= 0; --i)
        offset[i] = offset[i+1] * viewspec.extent(i+1);

      for(auto i = 0; i < NumDimensions; ++i)
      {
        pos[i] = index / offset[i] + viewspec.offset(i);
        index  = index % offset[i];
      }
    }
    else if (CoordArrangement == COL_MAJOR)
    {
      offset[0] = 1;
      for(auto i = 1; i < NumDimensions; ++i)
        offset[i] = offset[i-1] * viewspec.extent(i-1);

      for(auto i = NumDimensions-1; i >= 0; --i)
      {
        pos[i] = index / offset[i] + viewspec.offset(i);
        index  = index % offset[i];
      }
    }
    return pos;
  }

coords() [2/2]

template<size_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

template<MemArrange CoordArrangement = Arrangement>

std::array<IndexType, NumDimensions> dash::LocalMemoryLayout< NumDimensions, Arrangement, IndexType >::coords ( IndexType  index ) const

inline

Convert given linear offset (index) to cartesian coordinates.

Inverse of at(...).

Definition at line 773 of file Cartesian.h.

References dash::CartesianSpace< NumDimensions, SizeType >::extents(), dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::extents(), and dash::typestr().

                                                                   {
    if (!_distspec.is_tiled()) {
      // Default case, no tiles
      return parent_t::coords(index);
    }
    // Tiles in at least one dimension
    // TODO
    DASH_THROW(dash::exception::NotImplemented,
               "CartesianIndexSpace::coords(IndexType) not implemented for tiles!");
  }

extent()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

SizeType dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::extent ( dim_t  dim ) const

inlineinherited

The extent of the cartesian space in the given dimension.

Parameters

dim	The dimension in the coordinate

Returns

The extent in the given dimension

Definition at line 412 of file Cartesian.h.

Referenced by dash::TilePattern< NumDimensions, Arrangement, IndexType >::at(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::at(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::at(), dash::BlockPattern< 1, ROW_MAJOR, dash::default_index_t >::block(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::block(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::block(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::block(), dash::BlockPattern< 1, ROW_MAJOR, dash::default_index_t >::block_at(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::block_at(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::block_at(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::block_at(), dash::BlockPattern< 1, ROW_MAJOR, dash::default_index_t >::blocksize(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::blocksize(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::blocksize(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::blocksize(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::coords(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::coords(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::extent(), dash::BlockPattern< 1, ROW_MAJOR, dash::default_index_t >::extent(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::extent(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::extent(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::global(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::global(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::global(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::global_at(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::global_at(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::global_at(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::local(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::local(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::local_at(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::local_at(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::local_at(), dash::BlockPattern< 1, ROW_MAJOR, dash::default_index_t >::local_block(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::local_block(), dash::BlockPattern< 1, ROW_MAJOR, dash::default_index_t >::local_block_at(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::local_block_at(), dash::BlockPattern< 1, ROW_MAJOR, dash::default_index_t >::local_block_local(), dash::BlockPattern< 1, ROW_MAJOR, dash::default_index_t >::local_coords(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::local_coords(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::local_coords(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::local_coords(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::local_extent(), dash::BlockPattern< 1, ROW_MAJOR, dash::default_index_t >::local_extent(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::local_extent(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::local_extent(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::local_index(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::ndim(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::ndim(), dash::BlockPattern< 1, ROW_MAJOR, dash::default_index_t >::underfilled_blocksize(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::underfilled_blocksize(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::unit_at(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::unit_at(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::unit_at(), and dash::BlockPattern< 1, ROW_MAJOR, dash::default_index_t >::unit_at().

                                   {
    DASH_ASSERT_RANGE(
      0, dim, NumDimensions-1,
      "Given dimension " << dim <<
      " for CartesianIndexSpace::extent(dim) is out of bounds");
    return _extents[dim];
  }

extents()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

constexpr const extents_type& dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::extents ( ) const

inlinenoexceptinherited

Extents of the cartesian space, by dimension.

Definition at line 402 of file Cartesian.h.

Referenced by dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::at(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::block(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::block(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::block(), dash::LocalMemoryLayout< NumDimensions, Arrangement, IndexType >::coords(), dash::BlockPattern< 1, ROW_MAJOR, dash::default_index_t >::extents(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::extents(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::extents(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::extents(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::local_at(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::local_at(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::local_at(), dash::BlockPattern< 1, ROW_MAJOR, dash::default_index_t >::local_block(), dash::BlockPattern< 1, ROW_MAJOR, dash::default_index_t >::local_block_local(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::local_block_local(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::local_block_local(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::local_block_local(), dash::BlockPattern< 1, ROW_MAJOR, dash::default_index_t >::local_extents(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::local_extents(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::ndim(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::ndim(), dash::BlockPattern< 1, ROW_MAJOR, dash::default_index_t >::sizespec(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::sizespec(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::sizespec(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::sizespec(), dash::BlockPattern< 1, ROW_MAJOR, dash::default_index_t >::underfilled_blocksize(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::underfilled_blocksize(), and dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::unit_at().

                                                          {
    return _extents;
  }

operator!=()

template<size_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

constexpr bool dash::LocalMemoryLayout< NumDimensions, Arrangement, IndexType >::operator!= ( const self_t &  other ) const

inline

Inequality comparison operator.

Definition at line 674 of file Cartesian.h.

                                                        {
    return !(*this == other);
  }

operator==()

template<size_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

bool dash::LocalMemoryLayout< NumDimensions, Arrangement, IndexType >::operator== ( const self_t &  other ) const

inline

Equality comparison operator.

Definition at line 664 of file Cartesian.h.

                                              {
    if (!(parent_t::operator==(other))) {
      return false;
    }
    return _distspec == other._distspec;
  }

rank()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

constexpr dim_t dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::rank ( ) const

inlinenoexceptinherited

The number of dimension in the cartesian space with extent greater than 1.

See also

num_dimensions()

Returns

The number of dimensions in the coordinate

Definition at line 315 of file Cartesian.h.

                                        {
    return _rank;
  }

resize() [1/4]

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

template<typename SizeType_ >

void dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::resize ( const std::array< SizeType_, NumDimensions > &  extents )

inlineinherited

Change the extent of the cartesian space in every dimension.

Definition at line 363 of file Cartesian.h.

                                                                  {
    // Update size:
    _size = 1;
    for(auto i = 0; i < NumDimensions; i++ ) {
      _extents[i] = static_cast<SizeType>(extents[i]);
      _size      *= _extents[i];
    }
    // Update offsets:
    _offset_row_major[NumDimensions-1] = 1;
    for(auto i = NumDimensions-2; i >= 0; --i) {
      _offset_row_major[i] = _offset_row_major[i+1] * _extents[i+1];
    }
    _offset_col_major[0] = 1;
    for(auto i = 1; i < NumDimensions; ++i) {
      _offset_col_major[i] = _offset_col_major[i-1] * _extents[i-1];
    }
  }

resize() [2/4]

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

void dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::resize ( dim_t  dim, SizeType  extent  )

inlineinherited

Change the extent of the cartesian space in the given dimension.

Definition at line 384 of file Cartesian.h.

                                          {
    _extents[dim] = extent;
    resize(_extents);
  }

resize() [3/4]

template<size_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

template<typename... Args>

void dash::LocalMemoryLayout< NumDimensions, Arrangement, IndexType >::resize ( SizeType  arg, Args...  args  )

inline

Change the extent of the cartesian space in every dimension.

Definition at line 682 of file Cartesian.h.

References dash::CartesianSpace< NumDimensions, SizeType >::extents(), and dash::CartesianSpace< NumDimensions, SizeType >::resize().

                                          {
    static_assert(
      sizeof...(Args) == NumDimensions-1,
      "Invalid number of arguments");
    std::array<SizeType, NumDimensions> extents =
      {{ arg, (SizeType)(args)... }};
    resize(extents);
  }

resize() [4/4]

template<size_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

template<typename SizeType_ >

void dash::LocalMemoryLayout< NumDimensions, Arrangement, IndexType >::resize ( std::array< SizeType_, NumDimensions >  extents )

inline

Change the extent of the cartesian space in every dimension.

Definition at line 695 of file Cartesian.h.

                                                          {
    if (!_distspec.is_tiled()) {
      parent_t::resize(extents);
    }
    // Tiles in at least one dimension
    // TODO
    DASH_THROW(dash::exception::NotImplemented,
               "CartesianIndexSpace::resize(IndexType) not implemented for tiles!");
  }

size()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

constexpr SizeType dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::size ( ) const

inlinenoexceptinherited

The number of discrete elements within the space spanned by the coordinate.

Returns

The number of discrete elements in the coordinate's space

Definition at line 395 of file Cartesian.h.

Referenced by dash::TilePattern< NumDimensions, Arrangement, IndexType >::at(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::at(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::at(), dash::BlockPattern< 1, ROW_MAJOR, dash::default_index_t >::capacity(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::capacity(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::capacity(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::capacity(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::coords(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::coords(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::global(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::global(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::global(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::global_at(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::global_at(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::global_at(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::local_at(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::local_at(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::local_at(), dash::BlockPattern< 1, Arrangement, IndexType >::local_block_at(), dash::BlockPattern< 1, ROW_MAJOR, dash::default_index_t >::max_blocksize(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::max_blocksize(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::max_blocksize(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::max_blocksize(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::ndim(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::ndim(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::num_units(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::num_units(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::num_units(), dash::BlockPattern< 1, ROW_MAJOR, dash::default_index_t >::size(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::size(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::size(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::size(), dash::BlockPattern< 1, ROW_MAJOR, dash::default_index_t >::underfilled_blocksize(), and dash::TilePattern< NumDimensions, Arrangement, IndexType >::underfilled_blocksize().

                                           {
    return _size;
  }

x()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

template<dim_t U = NumDimensions>

constexpr std::enable_if< (U > 0), SizeType >::type dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::x ( SizeType  offs ) const

inlineinherited

Accessor for dimension 1 (x), enabled for dimensionality > 0.

Definition at line 591 of file Cartesian.h.

                         {
    return coords(offs)[0];
  }

y()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

template<dim_t U = NumDimensions>

constexpr std::enable_if< (U > 1), SizeType >::type dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::y ( SizeType  offs ) const

inlineinherited

Accessor for dimension 2 (y), enabled for dimensionality > 1.

Definition at line 600 of file Cartesian.h.

                         {
    return coords(offs)[1];
  }

z()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

template<dim_t U = NumDimensions>

constexpr std::enable_if< (U > 2), SizeType >::type dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::z ( SizeType  offs ) const

inlineinherited

Accessor for dimension 3 (z), enabled for dimensionality > 2.

Definition at line 609 of file Cartesian.h.

                         {
    return coords(offs)[2];
  }

---

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

• /tmp/tmporruphar/dash/include/dash/Cartesian.h