IndexRange.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__ads_array_IndexRange_h__)
#define __ads_array_IndexRange_h__

#include "FixedArray.h"

#include "../iterator/TrivialOutputIterator.h"
#include "../utility/string.h"

#include <iostream>
#include <string>
#include <sstream>

BEGIN_NAMESPACE_ADS


template<int N, typename T = int>
class IndexRange {
  //
  // Public types.
  //

public:

  typedef T index_type;
  typedef FixedArray<N,index_type> multi_index_type;

  //
  // Member data
  //

private:

  multi_index_type _lbounds, _ubounds;

public:

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

  IndexRange() :
    _lbounds(index_type(0)),
    _ubounds(index_type(0))
  {}

  IndexRange(const index_type ubound) :
    _lbounds(index_type(0)),
    _ubounds(ubound) {
    LOKI_STATIC_CHECK(N == 1, DimensionMustBe1);
  }

  IndexRange(const multi_index_type& ubounds) :
    _lbounds(index_type(0)),
    _ubounds(ubounds)
  {}

  IndexRange(const multi_index_type& lbounds, 
             const multi_index_type& ubounds) :
    _lbounds(lbounds),
    _ubounds(ubounds)
  {}

  IndexRange(const index_type lb0, const index_type ub0) :
    _lbounds(lb0),
    _ubounds(ub0) {
    LOKI_STATIC_CHECK(N == 1, DimensionMustBe1);
  }

  IndexRange(const index_type lb0, const index_type lb1, 
              const index_type ub0, const index_type ub1) :
    _lbounds(lb0, lb1),
    _ubounds(ub0, ub1) {
    LOKI_STATIC_CHECK(N == 2, DimensionMustBe2);
  }

  IndexRange(const index_type lb0, 
              const index_type lb1, 
              const index_type lb2, 
              const index_type ub0,
              const index_type ub1,
              const index_type ub2) :
    _lbounds(lb0, lb1, lb2),
    _ubounds(ub0, ub1, ub2) {
    LOKI_STATIC_CHECK(N == 3, DimensionMustBe3);
  }

  IndexRange(const IndexRange& x) :
    _lbounds(x._lbounds),
    _ubounds(x._ubounds)
  {}

  ~IndexRange()
  {}

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

  IndexRange& 
  operator=(const IndexRange& other) {
    if (&other != this) {
      _lbounds = other._lbounds;
      _ubounds = other._ubounds;
    }
    return *this;
  }

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

  void
  swap(IndexRange& other) {
    _lbounds.swap(other._lbounds);
    _ubounds.swap(other._ubounds);
  }

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

  static
  int
  dimension() {
    return N;
  }

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

  const multi_index_type&
  lbounds() const {     
    return _lbounds;
  }

  const multi_index_type&
  ubounds() const {     
    return _ubounds;
  }

  index_type
  lbound(const index_type i) const {    
    return _lbounds[i];
  }

  index_type
  ubound(const index_type i) const {    
    return _ubounds[i];
  }


  multi_index_type 
  extents() const {     
    return _ubounds - _lbounds;
  }

  index_type 
  content() const {     
    return computeProduct(extents());
  }

  bool
  empty() const {
    for (int i = 0; i != N; ++i) {
      if (_ubounds[i] <= _lbounds[i]) {
        return true;
      }
    }
    return false;
  }

  bool
  is_in(const multi_index_type& x) const {
    for (int i = 0; i != N; ++i) {
      if (x[i] < _lbounds[i] || _ubounds[i] <= x[i]) {
        return false;
      }
    }
    return true;
  }


  bool
  is_in(const index_type x) const {
    LOKI_STATIC_CHECK(N == 1, DimensionMustBe1);
    return (_lbounds[0] <= x && x < _ubounds[0]);
  }


  bool
  is_in(const index_type x, const index_type y) const {
    LOKI_STATIC_CHECK(N == 2, DimensionMustBe2);
    return (_lbounds[0] <= x && x < _ubounds[0] &&
            _lbounds[1] <= y && y < _ubounds[1]);
  }


  bool
  is_in(const index_type x, const index_type y, const index_type z) const {
    LOKI_STATIC_CHECK(N == 3, DimensionMustBe3);
    return (_lbounds[0] <= x && x < _ubounds[0] &&
             _lbounds[1] <= y && y < _ubounds[1] &&
             _lbounds[2] <= z && z < _ubounds[2]);
  }

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


  index_type 
  lbound() const {
    LOKI_STATIC_CHECK(N == 1, DimensionMustBe1);
    return lbounds()[0];
  }

  index_type 
  ubound() const {      
    LOKI_STATIC_CHECK(N == 1, DimensionMustBe1);
    return ubounds()[0];
  }


  index_type 
  extent() const {      
    LOKI_STATIC_CHECK(N == 1, DimensionMustBe1);
    return ubound() - lbound();
  }

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

  void
  set_lbounds(const multi_index_type& lbounds) {        
    _lbounds = lbounds;
  }

  void
  set_ubounds(const multi_index_type& ubounds) {        
    _ubounds = ubounds;
  }


  void
  set_lbounds(const index_type lb0) {   
    LOKI_STATIC_CHECK(N == 1, DimensionMustBe1);
    _lbounds[0] = lb0;
  }


  void
  set_ubounds(const index_type ub0) {   
    LOKI_STATIC_CHECK(N == 1, DimensionMustBe1);
    _ubounds[0] = ub0;
  }


  void
  set_lbounds(const index_type lb0, const index_type lb1) {     
    LOKI_STATIC_CHECK(N == 2, DimensionMustBe2);
    _lbounds[0] = lb0;
    _lbounds[1] = lb1;
  }


  void
  set_ubounds(const index_type ub0, const index_type ub1) {     
    LOKI_STATIC_CHECK(N == 2, DimensionMustBe2);
    _ubounds[0] = ub0;
    _ubounds[1] = ub1;
  }


  void
  set_lbounds(const index_type lb0, const index_type lb1, 
              const index_type lb2) {   
    LOKI_STATIC_CHECK(N == 3, DimensionMustBe3);
    _lbounds[0] = lb0;
    _lbounds[1] = lb1;
    _lbounds[2] = lb2;
  }


  void
  set_ubounds(const index_type ub0, const index_type ub1, 
              const index_type ub2) {   
    LOKI_STATIC_CHECK(N == 3, DimensionMustBe3);
    _ubounds[0] = ub0;
    _ubounds[1] = ub1;
    _ubounds[2] = ub2;
  }

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

  void
  set_lbound(const index_type lbound) {
    set_lbounds(lbound);
  }

  void
  set_ubound(const index_type ubound) {
    set_ubounds(ubound);
  }

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


  bool
  operator==(const IndexRange& x) const {
    return _lbounds == x.lbounds() && _ubounds == x.ubounds();
  }

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


  void
  put(std::ostream& out) const {
    out << _lbounds << " " << _ubounds;
  }


  void
  get(std::istream& in) {
    // Get a line from the input stream.  We assume that the index range 
    // must be written on one line.
    std::string line;
    // I loop here to skip blank lines.
    do {
      // CONTINUE: I should handle lines with only white space.
      std::getline(in, line);
    } while (line.empty() && in.good());
    // Count the numbers in the line.
    const int Size = ads::split(line, " ", 
                                ads::constructTrivialOutputIterator());
    // If they specified extents.
    if (Size == N) {
      // Set the lower bounds to zero.
      _lbounds = 0;
      // Read the extents as upper bounds.
      std::istringstream stream(line);
      stream >> _ubounds;
    }
    // If they specified lower and upper bounds.
    else if (Size == 2 * N) {
      // Read the lower and upper bounds.
      std::istringstream stream(line);
      stream >> _lbounds >> _ubounds;
    }
    // Otherwise, it is an error.
    else {
      std::cerr 
        << "Error in reading an IndexRange:\n"
        << "Wrong number of numbers.  We expected either " << N
        << " or " << 2 * N << "\n"
        << "but got " << Size << "\n";
      assert(false);
    }
  }

  void
  write(std::ostream& out) const {
    _lbounds.write(out);
    _ubounds.write(out);
  }

  void
  read(std::istream& in) {
    _lbounds.read(in);
    _ubounds.read(in);
  }

};

//
// Equality Operators
//

// CONTINUE: I don't think that I need this.
#if 0


template<int N, typename T>
inline
bool
operator==(const IndexRange<N,T>& a, const IndexRange<N,T>& b) {
  return a.is_equal(b);
}
#endif


template<int N, typename T>
inline
bool
operator!=(const IndexRange<N,T>& a, const IndexRange<N,T>& b) {
  return !(a == b);
}


//
// File I/O
//


template<int N, typename T>
inline
std::ostream&
operator<<(std::ostream& out, const IndexRange<N,T>& x) {
  x.put(out);
  return out;
}


template<int N, typename T>
inline
std::istream&
operator>>(std::istream& in, IndexRange<N,T>& x) {
  x.get(in);
  return in;
}

//
// Mathematical operations.
//


template<int N, typename T>
inline
void
compute_intersection(const IndexRange<N,T>& x, const IndexRange<N,T>& y, 
                     IndexRange<N,T>& result) {
  typename IndexRange<N,T>::multi_index_type lower, upper;
  for (int n = 0; n != N; ++n) {
    lower[n] = std::max(x.lbound(n), y.lbound(n));
    upper[n] = std::min(x.ubound(n), y.ubound(n));
    // An empty range has the same lower and upper bounds.
    upper[n] = std::max(lower[n], upper[n]);
  }
  result.set_lbounds(lower);
  result.set_ubounds(upper);
}


END_NAMESPACE_ADS

#endif

---