ArrayIndexingBase.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__ArrayIndexingBase_h__)
#define __ArrayIndexingBase_h__

// If we are debugging the whole ads package.
#if defined(DEBUG_ads) && !defined(DEBUG_ArrayIndexingBase)
#define DEBUG_ArrayIndexingBase
#endif

#include "FixedArray.h"
#include "IndexRange.h"

#include <iostream>

BEGIN_NAMESPACE_ADS


template <int N>
class ArrayIndexingBase {
  //
  // Public types.
  //

public:


  typedef int size_type;

  typedef FixedArray<N,int> index_type;
  typedef IndexRange<N,int> range_type;

private:

  //
  // Member data.
  //

  // Extents (lengths) in each dimension.
  index_type _extents;
  // The index ranges.
  range_type _ranges;
  // Strides between elements in each dimension.
  index_type _strides;

protected:

  //--------------------------------------------------------------------------
  // @{

  ArrayIndexingBase() :
    _extents(0),
    _ranges(),
    _strides(0)
  {}

  ArrayIndexingBase(const ArrayIndexingBase& x) :
    _extents(x._extents),
    _ranges(x._ranges),
    _strides(x._strides)
  {}

  ArrayIndexingBase& 
  operator=(const ArrayIndexingBase& x) {
    if (&x != this) {
      _extents = x._extents;
      _ranges = x._ranges;
      _strides = x._strides;
    }
    return *this;
  }

  explicit
  ArrayIndexingBase(const index_type& extents) :
    _extents(extents),
    _ranges(extents),
    _strides() {
    compute_strides();
  }

  void
  rebuild(const index_type& extents) {
    _extents = extents;
    _ranges.set_lbounds(index_type(0));
    _ranges.set_ubounds(extents);
    compute_strides();
  }

  explicit
  ArrayIndexingBase(const range_type& ranges) :
    _extents(ranges.extents()),
    _ranges(ranges),
    _strides() {
    compute_strides();
  }

  void
  rebuild(const range_type& ranges) {
    _extents = ranges.extents();
    _ranges = ranges;
    compute_strides();
  }

  void
  swap(ArrayIndexingBase& x) {
    _extents.swap(x._extents);
    _ranges.swap(x._ranges);
    _strides.swap(x._strides);
  }

  ~ArrayIndexingBase()
  {}

  // @}

public:

  //--------------------------------------------------------------------------
  // @{

  static
  int
  rank() {
    return N;
  }

  // @}
  //--------------------------------------------------------------------------
  // @{

  const index_type&
  extents() const { 
    return _extents; 
  }

  size_type 
  extent(const int i) const { 
    return _extents[i]; 
  }

  const range_type&
  ranges() const { 
    return _ranges; 
  }

  const index_type&
  lbounds() const { 
    return _ranges.lbounds();
  }

  const index_type&
  ubounds() const { 
    return _ranges.ubounds();
  }

  int
  lbound(const int i) const { 
    return _ranges.lbound(i);
  }

  int
  ubound(const int i) const { 
    return _ranges.ubound(i);
  }

  const index_type& 
  strides() const {
    return _strides;
  }

  // @}
  //--------------------------------------------------------------------------
  // @{

  int
  index(const index_type& mi) const {
    static index_type translated_indices;
#ifdef DEBUG_ArrayIndexing
    assert(_ranges.is_in(mi));
#endif
    translated_indices = mi;
    translated_indices -= _ranges.lbounds();
    return internal::dot(translated_indices, _strides);
  }


  int
  index(const int i0, const int i1) const { 
    LOKI_STATIC_CHECK(N == 2, Dimension_must_be_2); 
#ifdef DEBUG_ArrayIndexing
    assert(_ranges.is_in(i0, i1));
#endif
    return (i0 - _ranges.lbound(0)) * _strides[0] + 
      (i1 - _ranges.lbound(1)) * _strides[1];
  }


  int
  index(const int i0, const int i1, const int i2) const { 
    LOKI_STATIC_CHECK(N == 3, Dimension_must_be_3); 
#ifdef DEBUG_ArrayIndexing
    assert(_ranges.is_in(i0, i1, i2));
#endif
    return (i0 - _ranges.lbound(0)) * _strides[0] + 
      (i1 - _ranges.lbound(1)) * _strides[1] + 
      (i2 - _ranges.lbound(2)) * _strides[2];
  }


  void 
  index_to_indices(const int index, int& i, int& j) const {
    LOKI_STATIC_CHECK(N == 2, Dimension_must_be_2);
#ifdef DEBUG_ArrayIndexing
    assert(_strides[0] == 1);
#endif
    j = index / _strides[1] + _ranges.lbound(1);
    i = index % _strides[1] + _ranges.lbound(0);
#ifdef DEBUG_ArrayIndexing
    assert(_ranges.is_in(i, j));
#endif
  }


  void 
  index_to_indices(int index, int& i, int& j, int& k) const {
    LOKI_STATIC_CHECK(N == 3, Dimension_must_be_3);
#ifdef DEBUG_ArrayIndexing
    assert(_strides[0] == 1);
#endif
    k = index / _strides[2] + _ranges.lbound(2);
    index %= _strides[2];
    j = index / _strides[1] + _ranges.lbound(1);
    i = index % _strides[1] + _ranges.lbound(0);
#ifdef DEBUG_ArrayIndexing
    assert(_ranges.is_in(i, j, k));
#endif
  }


  void 
  index_to_indices(const int index, ads::FixedArray<2,int>& multi_index) const
  {
    index_to_indices(index, multi_index[0], multi_index[1]);
  }


  void 
  index_to_indices(const int index, ads::FixedArray<3,int>& multi_index) const
  {
    index_to_indices(index, multi_index[0], multi_index[1], multi_index[2]);
  }

  // @}
  //--------------------------------------------------------------------------
  // @{

  void
  put(std::ostream& out) const {
    out << ranges() << '\n';
  }

  void
  write(std::ostream& out) const {
    out.write(reinterpret_cast<const char*>(& _ranges), 
               sizeof(range_type));
  }

  // @}
  //--------------------------------------------------------------------------
  // @{
  
  bool
  operator==(const ArrayIndexingBase<N>& x) const {
    return ranges() == x.ranges();
  }

  // @}

protected:

  //
  // Protected member functions.
  //

  void
  compute_strides() {
    _strides[0] = 1;
    for (int i = 1; i != N; ++i) {
      _strides[i] = _strides[i-1] * _extents[i-1];
    }
  }

  int
  root_offset(const index_type& mi) const {
#ifdef DEBUG_ArrayIndexing
    assert(_ranges.is_in(mi));
#endif
    return internal::dot(mi, _strides);
  }

  int
  root_offset(const int i0, const int i1) const { 
    LOKI_STATIC_CHECK(N == 2, Dimension_must_be_2); 
#ifdef DEBUG_ArrayIndexing
    assert(_ranges.is_in(i0, i1));
#endif
    return i0 * _strides[0] + i1 * _strides[1];
  }

  int
  root_offset(const int i0, const int i1, const int i2) const { 
    LOKI_STATIC_CHECK(N == 3, Dimension_must_be_3); 
#ifdef DEBUG_ArrayIndexing
    assert(_ranges.is_in(i0, i1, i2));
#endif
    return i0 * _strides[0] + i1 * _strides[1] + i2 * _strides[2];
  }

};

END_NAMESPACE_ADS

#define __ArrayIndexingBase1_h__
#include "ArrayIndexingBase1.h"
#undef __ArrayIndexingBase1_h__

#endif

---