ArrayUtils.h

Go to the documentation of this file.

 
#pragma once
 
#include <algorithm>
#include <array>
#include <cmath>
#include <functional>
#include <list>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <string>
#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 && 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 L2NormSquared(const Container &c) {
    return std::accumulate(std::cbegin(c), std::cend(c), 0.0, [](auto a, auto b) { return a + b * b; });
}
 
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;
}