ArrayUtils.h

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <cmath>
#include <list>
#include <numeric>
#include <set>
#include <sstream>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
namespace ArrayUtils {
 
// specialize a type for all of the STL containers.
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::list<Args...>> : std::true_type {};
template <typename... Args>
struct is_container<std::set<Args...>> : std::true_type {};
template <typename... Args>
struct is_container<std::unordered_set<Args...>> : std::true_type {};
} // namespace is_container_impl
 
template <typename T> struct is_container {
  static constexpr bool const value =
      is_container_impl::is_container<std::decay_t<T>>::value;
};
 
template <class Container>
[[nodiscard]] std::string
to_string(const Container &container, const std::string &delimiter = ", ",
          const std::array<std::string, 2> &surround = {"[", "]"}) {
  auto iter = std::cbegin(container);
  const auto end = std::cend(container);
  if (iter == end) {
    return surround[0] + surround[1];
  }
  std::ostringstream strStream;
  strStream << surround[0] << *iter;
  for (++iter; iter != end; ++iter) {
    strStream << delimiter << *iter;
  }
  strStream << surround[1];
  return strStream.str();
}
 
template <class Container, class F>
inline Container elementWisePairOp(const Container &lhs, const Container &rhs,
                                   F binaryFunction) {
  Container ret = lhs;
  auto retIter = std::begin(ret);
  auto lhsIter = std::cbegin(lhs);
  const auto lhsEnd = std::cend(lhs);
  auto rhsIter = std::cbegin(rhs);
  const auto rhsEnd = std::cend(rhs);
 
  for (; lhsIter != lhsEnd and rhsIter != rhsEnd;
       ++lhsIter, ++rhsIter, ++retIter) {
    *retIter = binaryFunction(*lhsIter, *rhsIter);
  }
 
  return ret;
}
 
template <class Scalar, class Container, class F>
inline Container elementWiseScalarOp(const Scalar &lhs, const Container &rhs,
                                     F binaryFunction) {
  Container ret = rhs;
  auto retIter = std::begin(ret);
  auto rhsIter = std::cbegin(rhs);
  const auto rhsEnd = std::cend(rhs);
 
  for (; rhsIter != rhsEnd; ++rhsIter, ++retIter) {
    *retIter = binaryFunction(lhs, *rhsIter);
  }
 
  return ret;
}
 
template <class Container> auto L2Norm(const Container &c) {
  return std::sqrt(std::accumulate(std::cbegin(c), std::cend(c), 0.0,
                                   [](auto a, auto b) { return a + b * b; }));
}
} // namespace ArrayUtils
 
 
template <class Container>
std::enable_if_t<ArrayUtils::is_container<Container>::value, std::ostream &>
operator<<(std::ostream &os, const Container &container) {
  os << ArrayUtils::to_string(container);
  return os;
}
 
template <class Container>
std::enable_if_t<ArrayUtils::is_container<Container>::value, Container>
operator+(const Container &lhs, const Container &rhs) {
  return ArrayUtils::elementWisePairOp(lhs, rhs, std::plus<>());
}
 
template <class Container>
std::enable_if_t<ArrayUtils::is_container<Container>::value, Container>
operator-(const Container &lhs, const Container &rhs) {
  return ArrayUtils::elementWisePairOp(lhs, rhs, std::minus<>());
}
 
template <class Container>
std::enable_if_t<ArrayUtils::is_container<Container>::value, Container>
operator*(const Container &lhs, const Container &rhs) {
  return ArrayUtils::elementWisePairOp(lhs, rhs, std::multiplies<>());
}
 
template <class Scalar, class Container>
std::enable_if_t<ArrayUtils::is_container<Container>::value, Container>
operator*(const Scalar &lhs, const Container &rhs) {
  return ArrayUtils::elementWiseScalarOp(lhs, rhs, std::multiplies<>());
}
 
template <class Container>
std::enable_if_t<ArrayUtils::is_container<Container>::value, bool>
operator==(const Container &lhs, const Container &rhs) {
  if (lhs.size() != rhs.size()) {
    return false;
  }
 
  auto lhsIter = std::cbegin(lhs);
  const auto lhsEnd = std::cend(lhs);
  auto rhsIter = std::cbegin(rhs);
 
  for (; lhsIter != lhsEnd; ++lhsIter, ++rhsIter) {
    if (*lhsIter != *rhs) {
      return false;
    }
  }
  return true;
}