initializer_list.h

Go to the documentation of this file.

/*
 *  This file is a part of TiledArray.
 *  Copyright (C) 2015  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_INITIALIZER_LIST_UTILS_H__INCLUDED
#define TILEDARRAY_INITIALIZER_LIST_UTILS_H__INCLUDED
#include <TiledArray/tiled_range.h>
#include <TiledArray/tiled_range1.h>
#include <TiledArray/type_traits.h>
#include <algorithm>         // copy
#include <array>             // array
#include <initializer_list>  // initializer_list
#include <type_traits>       // decay, false_type, true_type
 
namespace TiledArray {
 
//------------------------------------------------------------------------------
// InitializerListRank Struct
//------------------------------------------------------------------------------
 
template <typename T, typename SizeType = std::size_t>
struct InitializerListRank : std::integral_constant<SizeType, 0> {};
 
template <typename T, typename SizeType = std::size_t>
constexpr auto initializer_list_rank_v =
    InitializerListRank<T, SizeType>::value;
 
template <typename T, typename SizeType>
struct InitializerListRank<std::initializer_list<T>, SizeType>
    : std::integral_constant<SizeType,
                             initializer_list_rank_v<T, SizeType> + 1> {};
 
//------------------------------------------------------------------------------
// tiled_range_from_il free function
//------------------------------------------------------------------------------
 
template <typename T,
          typename U =
              std::array<TiledRange1, initializer_list_rank_v<std::decay_t<T>>>>
auto tiled_range_from_il(T&& il, U shape = {}) {
  using clean_type = std::decay_t<T>;
  constexpr auto ranks_left = initializer_list_rank_v<clean_type>;
 
  if constexpr (ranks_left == 0) {  // Scalar or end of recursion
    return TiledRange(shape.begin(), shape.end());
  } else {
    // The length of this initializer_list
    const auto length = il.size();
    TA_ASSERT(length > 0);
 
    // This nesting level = (total-nestings) - (nestings-left)
    const auto this_rank = shape.size() - ranks_left;
    shape[this_rank] = TiledRange1(0, length);
 
    // verify that each sub-IL (if a list) has same length
    const auto first_sub_il_it = il.begin();
    if constexpr (detail::is_initializer_list_v<
                      std::decay_t<decltype(*first_sub_il_it)>>) {
      auto sub_il_it = il.begin();
      [[maybe_unused]] const size_t sub_il_length = sub_il_it->size();
      for (++sub_il_it; sub_il_it != il.end(); ++sub_il_it) {
        TA_ASSERT(sub_il_it->size() == sub_il_length);
      }
    }
 
    return tiled_range_from_il(*first_sub_il_it, std::move(shape));
  }
  abort();  // unreachable
}
 
//------------------------------------------------------------------------------
// flatten_il free function
//------------------------------------------------------------------------------
 
template <typename T, typename OutputItr>
auto flatten_il(T&& il, OutputItr out_itr) {
  constexpr auto ranks_left = initializer_list_rank_v<std::decay_t<T>>;
 
  // We were given a scalar, just copy its value
  // (input of std::initializer_list ends recursion on ranks_left == 1)
  if constexpr (ranks_left == 0) {
    *out_itr = il;
    ++out_itr;
  }
  // We were given a vector or we have recursed to the most nested
  // initializer_list, either way copy the contents to the buffer
  else if constexpr (ranks_left == 1) {
    out_itr = std::copy(il.begin(), il.end(), out_itr);
  }
  // The initializer list is at least a matrix, so recurse over sub-lists
  else {
    const auto length = il.begin()->size();
    for (auto&& x : il) {
      TA_ASSERT(x.size() == length);  // sub-lists must be the same size
      out_itr = flatten_il(x, out_itr);
    }
  }
  return out_itr;
}
 
//------------------------------------------------------------------------------
// get_elem_from_il free function
//------------------------------------------------------------------------------
 
template <typename T, typename U>
auto get_elem_from_il(T idx, U&& il, std::size_t depth = 0) {
  constexpr auto nestings_left = initializer_list_rank_v<std::decay_t<U>>;
  TA_ASSERT(idx.size() == nestings_left + depth);
  if constexpr (nestings_left == 0) {  // Handle scalars
    return il;
  } else {
    // Make sure the current nesting is long enough
    TA_ASSERT(il.size() > static_cast<std::size_t>(idx[depth]));
    auto itr = il.begin() + idx[depth];
    if constexpr (nestings_left == 1) {
      return *itr;
    } else {
      return get_elem_from_il(std::forward<T>(idx), *itr, depth + 1);
    }
  }
  abort();  // unreachable
}
 
//------------------------------------------------------------------------------
// array_from_il free function
//------------------------------------------------------------------------------
 
template <typename ArrayType, typename T>
auto array_from_il(World& world, const TiledRange& trange, T&& il) {
  using tile_type = typename ArrayType::value_type;
 
  static_assert(initializer_list_rank_v<std::decay_t<T>> > 0,
                "value initializing rank 0 tensors is not supported");
 
  ArrayType rv(world, trange);
 
  for (auto itr = rv.begin(); itr != rv.end(); ++itr) {
    auto range = rv.trange().make_tile_range(itr.index());
    tile_type tile(range);
    for (auto idx : range) {
      tile(idx) = get_elem_from_il(idx, il);
    }
    *itr = tile;
  }
  return rv;
}
 
template <typename ArrayType, typename T>
auto array_from_il(World& world, T&& il) {
  auto trange = tiled_range_from_il(il);
  return array_from_il<ArrayType, T>(world, std::move(trange),
                                     std::forward<T>(il));
}
 
namespace detail {
 
// Typedef of an initializer list for a vector
template <typename T>
using vector_il = std::initializer_list<T>;
 
// Typedef of an initializer list for a matrix
template <typename T>
using matrix_il = std::initializer_list<vector_il<T>>;
 
// Typedef of an il for a rank 3 tensor
template <typename T>
using tensor3_il = std::initializer_list<matrix_il<T>>;
 
// Typedef of an il for a rank 4 tensor
template <typename T>
using tensor4_il = std::initializer_list<tensor3_il<T>>;
 
// Typedef of an il for a rank 5 tensor
template <typename T>
using tensor5_il = std::initializer_list<tensor4_il<T>>;
 
// Typedef of an il for a rank 6 tensor
template <typename T>
using tensor6_il = std::initializer_list<tensor5_il<T>>;
 
}  // namespace detail
 
}  // namespace TiledArray
 
#endif  // TILEDARRAY_INITIALIZER_LIST_UTILS_H__INCLUDED