Core.hpp

Go to the documentation of this file.

#ifndef AI_TOOLBOX_UTILS_CORE_HEADER_FILE
#define AI_TOOLBOX_UTILS_CORE_HEADER_FILE
 
#include <cmath>
#include <limits>
#include <compare>
 
#include <AIToolbox/Types.hpp>
 
#include <boost/functional/hash.hpp>
 
namespace AIToolbox {
    constexpr auto equalToleranceSmall = 0.000001;
    constexpr auto equalToleranceGeneral = 0.00000000001;
 
    inline unsigned ceil(unsigned x, unsigned y) {
        return (x + y - 1) / y;
    }
 
    inline bool checkEqualSmall(const double a, const double b) {
        return ( std::fabs(a - b) <= equalToleranceSmall );
    }
 
    inline bool checkDifferentSmall(const double a, const double b) {
        return !checkEqualSmall(a,b);
    }
 
    inline bool checkEqualGeneral(const double a, const double b) {
        if ( checkEqualSmall(a,b) ) return true;
        return ( std::fabs(a - b) <= std::min(std::fabs(a), std::fabs(b)) * equalToleranceGeneral );
    }
 
    inline bool checkDifferentGeneral(const double a, const double b) {
        return !checkEqualGeneral(a,b);
    }
 
    template <typename V>
    bool checkEqualSmall(const V & v, const double d) {
        for (decltype(v.size()) i = 0; i < v.size(); ++i)
            if (!checkEqualSmall(v[i], d)) return false;
 
        return true;
    }
 
    template <typename V>
    bool checkDifferentSmall(const V & v, const double d) {
        return !checkEqualSmall(v, d);
    }
 
    template <typename V>
    bool checkEqualGeneral(const V & v, const double d) {
        for (decltype(v.size()) i = 0; i < v.size(); ++i)
            if (!checkEqualGeneral(v[i], d)) return false;
 
        return true;
    }
 
    template <typename V>
    bool checkDifferentGeneral(const V & v, const double d) {
        return !checkEqualGeneral(v, d);
    }
 
    template <typename V>
    std::strong_ordering veccmp(const V & lhs, const V & rhs) {
        assert(lhs.size() == rhs.size());
        for (decltype(lhs.size()) i = 0; i < lhs.size(); ++i) {
            // We can't use spaceship here to support floating points.
            if (lhs[i] == rhs[i]) continue;
            return lhs[i] > rhs[i] ? std::strong_ordering::greater : std::strong_ordering::less;
        }
        return std::strong_ordering::equal;
    }
 
    template <typename V>
    std::partial_ordering veccmpSmall(const V & lhs, const V & rhs) {
        assert(lhs.size() == rhs.size());
        for (decltype(lhs.size()) i = 0; i < lhs.size(); ++i) {
            if (checkEqualSmall(lhs[i], rhs[i])) continue;
            return lhs[i] <=> rhs[i];
        }
        return std::partial_ordering::equivalent;
    }
 
    template <typename V>
    std::partial_ordering veccmpGeneral(const V & lhs, const V & rhs) {
        assert(lhs.size() == rhs.size());
        for (decltype(lhs.size()) i = 0; i < lhs.size(); ++i) {
            if (checkEqualGeneral(lhs[i], rhs[i])) continue;
            return lhs[i] <=> rhs[i];
        }
        return std::partial_ordering::equivalent;
    }
 
    template <typename It>
    It sequential_sorted_find(It begin, It end, const typename std::iterator_traits<It>::value_type & elem) {
        while (begin != end && *begin < elem) ++begin;
        return begin;
    }
 
    template <typename It>
    bool sequential_sorted_contains(It begin, It end, const typename std::iterator_traits<It>::value_type & elem) {
        const auto it = sequential_sorted_find(begin, end, elem);
        if (it != end && *it == elem) return true;
        return false;
    }
 
    template <typename V>
    bool sequential_sorted_contains(const V & v, const V & elems) {
        assert(elems.size() <= v.size());
 
        if (v.size() == elems.size())
            return veccmp(v, elems) == 0;
 
        decltype(v.size()) i = 0, j = 0;
        while (j < elems.size()) {
            while (i < v.size() && v[i] < elems[j]) ++i;
            if (i == v.size() || v[i] > elems[j]) return false;
            ++i, ++j;
        }
        return j == elems.size();
    }
 
    template <typename T>
    void set_union_inplace(std::vector<T> & lhs, const std::vector<T> & rhs) {
        const auto mid = lhs.size();
        lhs.reserve(lhs.size() + rhs.size());
        std::set_difference(std::begin(rhs), std::end(rhs),
                            std::begin(lhs), std::end(lhs), std::back_inserter(lhs));
        std::inplace_merge(std::begin(lhs), std::begin(lhs)+mid, std::end(lhs));
    }
 
    template <typename It, typename F>
    auto max_element_unary(It begin, const It end, F unary_converter) {
        if (begin == end) return std::make_pair(end, 0.0);
        auto retval = begin;
        double max = std::invoke(unary_converter, *begin);
 
        while (++begin != end) {
            auto newV = std::invoke(unary_converter, *begin);
            if (newV > max) {
                retval = begin;
                max = newV;
            }
        }
        return std::make_pair(retval, max);
    }
 
    template <typename T, typename U>
    void copyDumb3D(const T & in, U & out, const size_t d1, const size_t d2, const size_t d3) {
        for ( size_t i = 0; i < d1; ++i )
            for ( size_t j = 0; j < d2; ++j )
                for ( size_t x = 0; x < d3; ++x )
                    out[i][j][x] = in[i][j][x];
    }
}
 
namespace Eigen {
    inline size_t hash_value(const AIToolbox::Vector & v) {
        return boost::hash_range(v.data(), v.data() + v.size());
    }
}
 
#endif