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

Defines a cartesian, totally-ordered index space by mapping linear indices to cartesian coordinates depending on memory order. 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	CartesianIndexSpace ()=default
	Default constructor, creates a cartesian index space of extent 0 in all dimensions. More...
	CartesianIndexSpace (const extents_type &extents)
	Constructor, creates a cartesian index space of given extents. More...
template<typename... Args>
	CartesianIndexSpace (SizeType arg, Args... args)
	Constructor, creates a cartesian index space of given extents. More...
constexpr dim_t	rank () const noexcept
	The number of dimension in the cartesian space with extent greater than 1. 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 (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<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...
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...

Friends
template<dim_t NDim_>
std::ostream &	operator<< (std::ostream &os, const CartesianIndexSpace< NDim_ > &cartesian_space)

Detailed Description

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

Defines a cartesian, totally-ordered index space by mapping linear indices to cartesian coordinates depending on memory order.

Note

Not derived from CartesianSpace to provide resizing in O(d) instead of O(2d).

Definition at line 239 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

The number of dimension in the cartesian space.

Definition at line 279 of file Cartesian.h.

Constructor & Destructor Documentation

CartesianIndexSpace() [1/3]

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

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

default

Default constructor, creates a cartesian index space of extent 0 in all dimensions.

CartesianIndexSpace() [2/3]

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

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

inline

Constructor, creates a cartesian index space of given extents.

Definition at line 290 of file Cartesian.h.

  : _extents(extents)
  {
    resize(extents);
  }

CartesianIndexSpace() [3/3]

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

template<typename... Args>

dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::CartesianIndexSpace ( SizeType  arg, Args...  args  )

inline

Constructor, creates a cartesian index space of given extents.

Definition at line 301 of file Cartesian.h.

  : _extents({{ }})
  {
    resize(arg, args...);
  }

Member Function Documentation

at() [1/3]

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

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

constexpr IndexType dash::CartesianIndexSpace< 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 429 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_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 >::global(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::global(), dash::BlockPattern< 1, ROW_MAJOR, dash::default_index_t >::global_at(), 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::BlockPattern< 1, ROW_MAJOR, dash::default_index_t >::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_at(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::local_block_at(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::local_index(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::unit_at(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::unit_at(), and dash::BlockPattern< 1, ROW_MAJOR, dash::default_index_t >::unit_at().

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

at() [2/3]

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

template<MemArrange AtArrangement = Arrangement, typename OffsetType >

IndexType dash::CartesianIndexSpace< 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 449 of file Cartesian.h.

                                                             {
    SizeType offs = 0;
    DASH_ASSERT_GT(_size, 0, "CartesianIndexSpace has size 0");
    for (auto i = 0; i < NumDimensions; i++) {
      DASH_ASSERT_RANGE(
        0,
        static_cast<IndexType>(point[i]),
        static_cast<IndexType>(_extents[i]-1),
        "Given coordinate for CartesianIndexSpace::at() exceeds extent");
      SizeType offset_dim = 0;
      if (AtArrangement == ROW_MAJOR) {
        offset_dim = _offset_row_major[i];
      } else if (AtArrangement == COL_MAJOR) {
        offset_dim = _offset_col_major[i];
      }
      offs += offset_dim * point[i];
    }
    return offs;
  }

at() [3/3]

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

template<MemArrange AtArrangement = Arrangement, typename OffsetType >

IndexType dash::CartesianIndexSpace< 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 482 of file Cartesian.h.

                                       {
    std::array<OffsetType, NumDimensions> coords{};
    for (auto d = 0; d < NumDimensions; ++d) {
      coords[d] = point[d] + viewspec.offset(d);
    }
    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

inline

Convert given linear offset (index) to cartesian coordinates.

Inverse of at(...).

Definition at line 497 of file Cartesian.h.

Referenced by 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 >::coords(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::coords(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::coords(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::coords(), dash::BlockPattern< 1, ROW_MAJOR, dash::default_index_t >::global(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::global(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::global(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::global(), 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_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::GlobViewIter< ElementT, PatternT, GlobMemT >::operator--(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::underfilled_blocksize(), dash::TilePattern< NumDimensions, Arrangement, IndexType >::unit_at(), dash::BlockPattern< 1, ROW_MAJOR, dash::default_index_t >::unit_at(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::unit_at(), and dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::unit_at().

  {
    DASH_ASSERT_GT(_size, 0, "CartesianIndexSpace has size 0");
    DASH_ASSERT_RANGE(
      0, index, static_cast<IndexType>(_size-1),
      "Given index for CartesianIndexSpace::coords() is out of bounds");

    ::std::array<IndexType, NumDimensions> pos{};
    if (CoordArrangement == ROW_MAJOR) {
      for(auto i = 0; i < NumDimensions; ++i) {
        pos[i] = index / _offset_row_major[i];
        index  = index % _offset_row_major[i];
      }
    } else if (CoordArrangement == COL_MAJOR) {
      for(auto i = NumDimensions-1; i >= 0; --i) {
        pos[i] = index / _offset_col_major[i];
        index  = index % _offset_col_major[i];
      }
    }
    return pos;
  }

coords() [2/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

inline

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;
  }

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

inline

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

inlinenoexcept

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<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

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

inline

Inequality comparison operator.

Definition at line 342 of file Cartesian.h.

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

operator==()

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

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

inline

Equality comparison operator.

Definition at line 322 of file Cartesian.h.

                                              {
    if (this == &other) {
      return true;
    }
    for(auto i = 0; i < NumDimensions; i++) {
      if (_extents[i] != other._extents[i]) {
        return false;
      }
      // Comparing either row- or column major offsets suffices:
      if (_offset_row_major[i] != other._offset_row_major[i]) {
        return false;
      }
    }
    // No need to compare _size as it is derived from _extents.
    return true;
  }

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

inlinenoexcept

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/3]

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

template<typename... Args>

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

inline

Change the extent of the cartesian space in every dimension.

Definition at line 350 of file Cartesian.h.

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

resize() [2/3]

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 )

inline

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() [3/3]

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  )

inline

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

Definition at line 384 of file Cartesian.h.

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

size()

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

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

inlinenoexcept

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

inline

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

inline

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

inline

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