ArrayUtils.h

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <iomanip>
#include <numeric>
#include <set>
#include <sstream>
#include <vector>
 
namespace autopas::utils::ArrayUtils {
 
// specialize a type for containers of type array and vector for use with templated overloaded stream operator.
namespace is_container_impl {
template <typename T>
struct is_container : std::false_type {};
template <typename T, std::size_t N>
struct is_container<std::array<T, N>> : std::true_type {};
 
template <typename... Args>
struct is_container<std::vector<Args...>> : std::true_type {};
 
template <typename... Args>
struct is_container<std::set<Args...>> : std::true_type {};
 
}  // namespace is_container_impl
 
template <typename T>
struct is_container {
  static constexpr bool const value =
      autopas::utils::ArrayUtils::is_container_impl::is_container<std::decay_t<T>>::value;
};
 
template <class output_t, class input_t, std::size_t SIZE>
[[nodiscard]] constexpr std::array<output_t, SIZE> static_cast_copy_array(const std::array<input_t, SIZE> &a) {
  std::array<output_t, SIZE> result{};
  for (std::size_t d = 0; d < SIZE; ++d) {
    result[d] = static_cast<output_t>(a[d]);
  }
  return result;
}
 
template <class Container, class Fun>
void to_string(std::ostream &os, const Container &container, const std::string &delimiter,
               const std::array<std::string, 2> &surround, Fun elemToString) {
  auto it = std::cbegin(container);
  const auto end = std::cend(container);
  if (it == end) {
    os << surround[0] << surround[1];
    return;
  }
  os << surround[0] << elemToString(*it);
  for (++it; it != end; ++it) {
    os << delimiter << elemToString(*it);
  }
  os << surround[1];
}
 
template <class Container>
void to_string(std::ostream &os, const Container &container, const std::string &delimiter = ", ",
               const std::array<std::string, 2> &surround = {"[", "]"}) {
  to_string(os, container, delimiter, surround, [](const auto &x) { return x; });
}
 
template <class Container, class Fun>
[[nodiscard]] std::string to_string(const Container &container, const std::string &delimiter,
                                    const std::array<std::string, 2> &surround, Fun elemToString) {
  std::ostringstream strStream;
  strStream << std::boolalpha;
  to_string(strStream, container, delimiter, surround, elemToString);
 
  return strStream.str();
}
 
template <class Container>
[[nodiscard]] std::string to_string(const Container &container, const std::string &delimiter = ", ",
                                    const std::array<std::string, 2> &surround = {"[", "]"}) {
  return to_string(container, delimiter, surround, [](const auto &elem) { return elem; });
}
 
template <class Container>
std::enable_if_t<autopas::utils::ArrayUtils::is_container<Container>::value, std::ostream &> operator<<(
    std::ostream &os, const Container &container) {
  const std::string &delimiter = ", ";
  const std::array<std::string, 2> &surround = {"[", "]"};
 
  to_string(os, container, delimiter, surround);
 
  return os;
}
 
template <class OuterContainerT>
void balanceVectors(OuterContainerT &vecvec) {
  balanceVectors(
      vecvec, [](auto &innerContainer) -> auto & { return innerContainer; });
}
 
template <class OuterContainerT, class F>
void balanceVectors(OuterContainerT &vecvec, F innerContainerToVec) {
  using InnerContainerT = typename OuterContainerT::value_type;
  using ElemT = typename std::remove_reference_t<
      std::invoke_result_t<decltype(innerContainerToVec), InnerContainerT &>>::value_type;
  // calculate vecvec statistics
  const auto vecvecSize = vecvec.size();
  if (vecvecSize == 0) {
    // nothing to do
    return;
  }
  const size_t numElem = std::transform_reduce(vecvec.begin(), vecvec.end(), 0, std::plus<>(),
                                               [&](auto &vec) { return innerContainerToVec(vec).size(); });
  const auto targetSize = static_cast<long>(numElem / vecvecSize);
  const auto remainder = numElem % vecvecSize;
 
  std::vector<ElemT> tmpStorage;
  // index of the first subvec that has too few elements
  size_t firstTooFew = 0;
  // repeat as long as there is something in the buffer but at least 2 iterations.
  for (int pass = 0; pass == 0 or not tmpStorage.empty(); ++pass) {
    // scan all subvecs that are not known to have the desired size
    for (size_t i = firstTooFew; i < vecvecSize; ++i) {
      auto &vec = innerContainerToVec(vecvec[i]);
      const auto thisTargetSize = i < remainder ? targetSize + 1 : targetSize;
      if (vec.size() > thisTargetSize) {
        // move what is too much to tmpStorage
        const auto startOfTooMuch = vec.begin() + thisTargetSize;
        tmpStorage.insert(tmpStorage.end(), std::make_move_iterator(startOfTooMuch),
                          std::make_move_iterator(vec.end()));
        vec.erase(startOfTooMuch, vec.end());
        // if firstTooFew points here bump it, since this vector is now satisfied
        if (firstTooFew == i) {
          ++firstTooFew;
        }
      } else if (vec.size() < thisTargetSize) {
        // fill too small vectors from storage
        vec.reserve(thisTargetSize);
        const long numMissing = thisTargetSize - vec.size();
        const auto startOfInsertion =
            tmpStorage.begin() + (std::max(0l, static_cast<long>(tmpStorage.size()) - numMissing));
        vec.insert(vec.end(), std::make_move_iterator(startOfInsertion), std::make_move_iterator(tmpStorage.end()));
        tmpStorage.erase(startOfInsertion, tmpStorage.end());
 
      } else if (firstTooFew == i) {
        // if firstTooFew points here bump it, since this vector is already satisfied
        ++firstTooFew;
      }
      // after the first pass all excess elements are collected. So as soon as everything is distributed we are done.
      if (pass > 0 and tmpStorage.empty()) {
        break;
      }
    }
  }
}
 
}  // namespace autopas::utils::ArrayUtils