tiled_range.h

Go to the documentation of this file.

/*
 * This file is a part of TiledArray.
 * Copyright (C) 2013  Virginia Tech
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef RANGE_H__INCLUDED
#define RANGE_H__INCLUDED

#include <TiledArray/tiled_range1.h>
#include <TiledArray/range.h>

namespace TiledArray {


  class TiledRange {
  private:

    void init() {
      const std::size_t rank = this->rank();

      // Indices used to store range start and finish.
      std::vector<size_type> start;
      std::vector<size_type> finish;
      std::vector<size_type> start_element;
      std::vector<size_type> finish_element;

      start.reserve(rank);
      finish.reserve(rank);
      start_element.reserve(rank);
      finish_element.reserve(rank);

      // Find the start and finish of the over all tiles and element ranges.
      for(unsigned int i = 0; i < rank; ++i) {
        start.push_back(ranges_[i].tiles_range().first);
        finish.push_back(ranges_[i].tiles_range().second);

        start_element.push_back(ranges_[i].elements_range().first);
        finish_element.push_back(ranges_[i].elements_range().second);
      }
      range_type(start, finish).swap(range_);
      range_type(start_element, finish_element).swap(elements_range_);
    }

  public:
    // typedefs
    typedef TiledRange TiledRange_;
    typedef Range range_type;  // represents elements/tiles range
    typedef std::size_t size_type;
    typedef range_type::index index;
    typedef range_type::size_array size_array;
    typedef std::vector<TiledRange1> Ranges;

    TiledRange() : range_(), elements_range_(), ranges_() { }

    template <typename InIter>
    TiledRange(InIter first, InIter last) :
      range_(), elements_range_(), ranges_(first, last)
    {
      init();
    }

    TiledRange(const std::initializer_list<std::initializer_list<size_type> >& list) :
      range_(), elements_range_(), ranges_(list.begin(), list.end())
    {
      init();
    }

    TiledRange(const std::initializer_list<TiledRange1>& list) :
      range_(), elements_range_(), ranges_(list.begin(), list.end())
    {
      init();
    }

    TiledRange(const TiledRange_& other) :
        range_(other.range_), elements_range_(other.elements_range_), ranges_(other.ranges_)
    { }


    TiledRange_& operator =(const TiledRange_& other) {
      if(this != &other)
        TiledRange_(other).swap(*this);
      return *this;
    }


    TiledRange_& operator *=(const Permutation& p) {
      TA_ASSERT(p.dim() == range_.rank());
      Ranges temp = p * ranges_;
      TiledRange(temp.begin(), temp.end()).swap(*this);
      return *this;
    }


    const range_type& tiles_range() const {
      return range_;
    }


    DEPRECATED const range_type& tiles() const {
      return tiles_range();
    }


    const range_type& elements_range() const {
      return elements_range_;
    }


    DEPRECATED const range_type& elements() const {
      return elements_range();
    }


    range_type tile(const size_type& i) const {
      return make_tile_range(i);
    }


    range_type make_tile_range(const size_type& i) const {
      TA_ASSERT(tiles_range().includes(i));
      return make_tile_range(tiles_range().idx(i));
    }


    template <typename Index>
    typename std::enable_if<!std::is_integral<Index>::value,
                            range_type>::type
    tile(const Index& index) const {
      return make_tile_range(index);
    }


    template <typename Index>
    typename std::enable_if<! std::is_integral<Index>::value, range_type>::type
    make_tile_range(const Index& index) const {
      const auto rank = range_.rank();
      TA_ASSERT(index.size() == rank);
      TA_ASSERT(range_.includes(index));
      typename range_type::index lower;
      typename range_type::index upper;
      lower.reserve(rank);
      upper.reserve(rank);
      unsigned d = 0;
      for(const auto& index_d: index) {
        lower.push_back(data()[d].tile(index_d).first);
        upper.push_back(data()[d].tile(index_d).second);
        ++d;
      }

      return range_type(lower, upper);
    }


    template <typename Integer>
    range_type
    tile(const std::initializer_list<Integer>& index) const {
      return make_tile_range(index);
    }


    template <typename Integer>
    range_type
    make_tile_range(const std::initializer_list<Integer>& index) const {
      return make_tile_range<std::initializer_list<Integer>>(index);
    }


    template <typename Index>
    typename std::enable_if<! std::is_integral<Index>::value, typename range_type::index>::type
    element_to_tile(const Index& index) const {
      const unsigned int rank = range_.rank();
      typename range_type::index result;
      result.reserve(rank);
      for(size_type i = 0; i < rank; ++i)
        result.push_back(ranges_[i].element_to_tile(index[i]));

      return result;
    }


    std::size_t rank() const { return ranges_.size(); }


    const TiledRange1& dim(std::size_t d) const {
      TA_ASSERT(d < rank());
      return ranges_[d];
    }


    const Ranges& data() const { return ranges_; }


    void swap(TiledRange_& other) {
      range_.swap(other.range_);
      elements_range_.swap(other.elements_range_);
      std::swap(ranges_, other.ranges_);
    }

  private:
    range_type range_; 
    range_type elements_range_; 
    Ranges ranges_; 
  };


  inline TiledRange operator *(const Permutation& p, const TiledRange& r) {
    TA_ASSERT(r.tiles_range().rank() == p.dim());
    TiledRange::Ranges data = p * r.data();

    return TiledRange(data.begin(), data.end());
  }

  inline void swap(TiledRange& r0, TiledRange& r1) { r0.swap(r1); }

  inline bool operator ==(const TiledRange& r1, const TiledRange& r2) {
    return (r1.tiles_range().rank() == r2.tiles_range().rank()) &&
        (r1.tiles_range() == r2.tiles_range()) && (r1.elements_range() == r2.elements_range()) &&
        std::equal(r1.data().begin(), r1.data().end(), r2.data().begin());
  }

  inline bool operator !=(const TiledRange& r1, const TiledRange& r2) {
    return ! operator ==(r1, r2);
  }

  inline std::ostream& operator<<(std::ostream& out, const TiledRange& rng) {
    out << "(" << " tiles = " << rng.tiles_range()
        << ", elements = " << rng.elements_range() << " )";
    return out;
  }

} // namespace TiledArray


#endif // RANGE_H__INCLUDED