ArrayUtils.h

Go to the documentation of this file.

 
#pragma once
 
#include <omp.h>
 
#include <algorithm>
#include <array>
#include <cmath>
#include <list>
#include <map>
#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; }));
}
 
template <>
inline auto L2Norm<std::array<double, 3>>(const std::array<double, 3>& c) {
    return std::sqrt(c[0] * c[0] + c[1] * c[1] + c[2] * c[2]);
}
 
template <class Container>
auto L2NormSquared(const Container& c) {
    return std::accumulate(std::cbegin(c), std::cend(c), 0.0, [](auto a, auto b) { return a + b * b; });
}
 
template <>
inline auto L2NormSquared<std::array<double, 3>>(const std::array<double, 3>& c) {
    return c[0] * c[0] + c[1] * c[1] + c[2] * c[2];
}
 
}  // 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;
}