tiled_range1.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 TILEDARRAY_TILED_RANGE1_H__INCLUDED
#define TILEDARRAY_TILED_RANGE1_H__INCLUDED
 
#include <TiledArray/error.h>
#include <TiledArray/type_traits.h>
#include <TiledArray/utility.h>
#include <cassert>
#include <initializer_list>
#include <mutex>
#include <vector>
 
// Forward declaration of MADNESS archive type traits
namespace madness {
namespace archive {
 
template <typename>
struct is_output_archive;
template <typename>
struct is_input_archive;
 
}  // namespace archive
}  // namespace madness
 
namespace TiledArray {
 
class TiledRange1 {
 private:
  struct Enabler {};
 
 public:
  typedef TA_1INDEX_TYPE index1_type;
  typedef std::pair<index1_type, index1_type> range_type;
  typedef std::vector<range_type>::const_iterator const_iterator;
 
  TiledRange1()
      : range_(0, 0), elements_range_(0, 0), tiles_ranges_(), elem2tile_() {}
 
  template <typename RandIter,
            typename std::enable_if<
                detail::is_random_iterator<RandIter>::value>::type* = nullptr>
  explicit TiledRange1(RandIter first, RandIter last)
      : range_(), elements_range_(), tiles_ranges_(), elem2tile_() {
    init_tiles_(first, last, 0);
  }
 
  TiledRange1(const TiledRange1& rng) = default;
 
  TiledRange1(TiledRange1&& rng) = default;
 
 
  template <typename... _sizes>
  explicit TiledRange1(const index1_type& t0, const _sizes&... t_rest) {
    const auto n = sizeof...(_sizes) + 1;
    index1_type tile_boundaries[n] = {t0, static_cast<index1_type>(t_rest)...};
    init_tiles_(tile_boundaries, tile_boundaries + n, 0);
  }
 
 
  template <typename Integer,
            typename = std::enable_if_t<std::is_integral_v<Integer>>>
  explicit TiledRange1(const std::initializer_list<Integer>& list) {
    init_tiles_(list.begin(), list.end(), 0);
  }
 
  TiledRange1& operator=(const TiledRange1& rng) = default;
 
  TiledRange1& operator=(TiledRange1&& rng) = default;
 
  const_iterator begin() const { return tiles_ranges_.begin(); }
 
  const_iterator end() const { return tiles_ranges_.end(); }
 
  bool empty() const { return tiles_ranges_.empty(); }
 
  const_iterator find(const index1_type& e) const {
    if (!includes(elements_range_, e)) return tiles_ranges_.end();
    const_iterator result = tiles_ranges_.begin();
    result += element_to_tile(e);
    return result;
  }
 
  [[deprecated]] const range_type& tiles() const { return range_; }
 
 
  const range_type& tiles_range() const { return range_; }
 
  const range_type& elements() const { return elements_range_; }
 
 
  const range_type& elements_range() const { return elements_range_; }
 
  index1_type tile_extent() const { return range_.second - range_.first; }
 
  index1_type extent() const {
    return elements_range_.second - elements_range_.first;
  }
 
 
  const range_type& tile(const index1_type i) const {
    TA_ASSERT(includes(range_, i));
    return tiles_ranges_[i - range_.first];
  }
 
 
  const index1_type& element_to_tile(const index1_type& i) const {
    TA_ASSERT(includes(elements_range_, i));
    if (elem2tile_.empty()) {
      init_elem2tile_();
    }
    return elem2tile_[i - elements_range_.first];
  }
 
  [[deprecated]] const index1_type& element2tile(const index1_type& i) const {
    return element_to_tile(i);
  }
 
 
  void swap(TiledRange1& other) {  // no throw
    std::swap(range_, other.range_);
    std::swap(elements_range_, other.elements_range_);
    std::swap(tiles_ranges_, other.tiles_ranges_);
    std::swap(elem2tile_, other.elem2tile_);
  }
 
  template <typename Archive,
            typename std::enable_if<madness::archive::is_input_archive<
                Archive>::value>::type* = nullptr>
  void serialize(const Archive& ar) {
    ar& range_& elements_range_& tiles_ranges_& elem2tile_;
  }
 
  template <typename Archive,
            typename std::enable_if<madness::archive::is_output_archive<
                Archive>::value>::type* = nullptr>
  void serialize(const Archive& ar) const {
    ar& range_& elements_range_& tiles_ranges_& elem2tile_;
  }
 
 private:
  static bool includes(const range_type& r, index1_type i) {
    return (i >= r.first) && (i < r.second);
  }
 
  template <typename RandIter>
  static void valid_(RandIter first, RandIter last) {
    // Verify at least 2 elements are present if the vector is not empty.
    TA_ASSERT((std::distance(first, last) >= 2) &&
              "TiledRange1 construction failed: You need at least 2 "
              "elements in the tile boundary list.");
    // Verify the requirement that a0 < a1 < a2 < ...
    for (; first != (last - 1); ++first) {
      TA_ASSERT(
          *first < *(first + 1) &&
          "TiledRange1 construction failed: Invalid tile boundary, tile "
          "boundary i must be greater than tile boundary i+1 for all i. ");
      TA_ASSERT(
          static_cast<index1_type>(*first) <
              static_cast<index1_type>(*(first + 1)) &&
          "TiledRange1 construction failed: Invalid tile boundary, tile "
          "boundary i must be greater than tile boundary i+1 for all i. ");
    }
  }
 
  template <typename RandIter>
  void init_tiles_(RandIter first, RandIter last,
                   index1_type start_tile_index) {
#ifndef NDEBUG
    valid_(first, last);
#endif  // NDEBUG
    range_.first = start_tile_index;
    range_.second = start_tile_index + last - first - 1;
    elements_range_.first = *first;
    elements_range_.second = *(last - 1);
    for (; first != (last - 1); ++first)
      tiles_ranges_.emplace_back(*first, *(first + 1));
  }
 
  void init_elem2tile_() const {
    // check for 0 size range.
    if ((elements_range_.second - elements_range_.first) == 0) return;
 
    static std::mutex mtx;
    {
      std::lock_guard<std::mutex> lock(mtx);
      if (elem2tile_.empty()) {
        // initialize elem2tile map
        elem2tile_.resize(elements_range_.second - elements_range_.first);
        const auto end = range_.second - range_.first;
        for (index1_type t = 0; t < end; ++t)
          for (index1_type e = tiles_ranges_[t].first;
               e < tiles_ranges_[t].second; ++e)
            elem2tile_[e - elements_range_.first] = t + range_.first;
      }
    }
  }
 
  friend std::ostream& operator<<(std::ostream&, const TiledRange1&);
 
  // TiledRange1 data
  range_type range_;           
  range_type elements_range_;  
  std::vector<range_type>
      tiles_ranges_;  
  mutable std::vector<index1_type>
      elem2tile_;  
 
};  // class TiledRange1
 
inline void swap(TiledRange1& r0, TiledRange1& r1) {  // no throw
  r0.swap(r1);
}
 
inline bool operator==(const TiledRange1& r1, const TiledRange1& r2) {
  return std::equal(r1.begin(), r1.end(), r2.begin()) &&
         (r1.tiles_range() == r2.tiles_range()) &&
         (r1.elements_range() == r2.elements_range());
}
 
inline bool operator!=(const TiledRange1& r1, const TiledRange1& r2) {
  return !operator==(r1, r2);
}
 
inline std::ostream& operator<<(std::ostream& out, const TiledRange1& rng) {
  out << "( tiles = [ " << rng.tiles_range().first << ", "
      << rng.tiles_range().second << " ), elements = [ "
      << rng.elements_range().first << ", " << rng.elements_range().second
      << " ) )";
  return out;
}
 
 
inline TiledRange1 concat(const TiledRange1& r1, const TiledRange1& r2) {
  std::vector<TiledRange1::index1_type> hashmarks;
  hashmarks.reserve(r1.tile_extent() + r2.tile_extent() + 1);
  if (!r1.empty()) {
    hashmarks.push_back(r1.tile(0).first);
    for (const auto& tile : r1) {
      hashmarks.push_back(tile.second);
    }
    for (const auto& tile : r2) {
      hashmarks.push_back(hashmarks.back() + tile.second - tile.first);
    }
    return TiledRange1(hashmarks.begin(), hashmarks.end());
  } else {
    return r2;
  }
}
 
 
inline bool is_congruent(const TiledRange1& r1, const TiledRange1& r2) {
  return std::equal(r1.begin(), r1.end(), r2.begin(),
                    [](const auto& tile1, const auto& tile2) {
                      return (tile1.second - tile1.first) ==
                             (tile2.second - tile2.first);
                    });
}
 
}  // namespace TiledArray
 
#endif  // TILEDARRAY_TILED_RANGE1_H__INCLUDED