🛠️🐜 Antkeeper superbuild with dependencies included
https://antkeeper.com
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
137 lines
5.0 KiB
137 lines
5.0 KiB
#ifndef ENTT_CORE_ALGORITHM_HPP
|
|
#define ENTT_CORE_ALGORITHM_HPP
|
|
|
|
#include <algorithm>
|
|
#include <functional>
|
|
#include <iterator>
|
|
#include <utility>
|
|
#include <vector>
|
|
#include "utility.hpp"
|
|
|
|
namespace entt {
|
|
|
|
/**
|
|
* @brief Function object to wrap `std::sort` in a class type.
|
|
*
|
|
* Unfortunately, `std::sort` cannot be passed as template argument to a class
|
|
* template or a function template.<br/>
|
|
* This class fills the gap by wrapping some flavors of `std::sort` in a
|
|
* function object.
|
|
*/
|
|
struct std_sort {
|
|
/**
|
|
* @brief Sorts the elements in a range.
|
|
*
|
|
* Sorts the elements in a range using the given binary comparison function.
|
|
*
|
|
* @tparam It Type of random access iterator.
|
|
* @tparam Compare Type of comparison function object.
|
|
* @tparam Args Types of arguments to forward to the sort function.
|
|
* @param first An iterator to the first element of the range to sort.
|
|
* @param last An iterator past the last element of the range to sort.
|
|
* @param compare A valid comparison function object.
|
|
* @param args Arguments to forward to the sort function, if any.
|
|
*/
|
|
template<typename It, typename Compare = std::less<>, typename... Args>
|
|
void operator()(It first, It last, Compare compare = Compare{}, Args &&...args) const {
|
|
std::sort(std::forward<Args>(args)..., std::move(first), std::move(last), std::move(compare));
|
|
}
|
|
};
|
|
|
|
/*! @brief Function object for performing insertion sort. */
|
|
struct insertion_sort {
|
|
/**
|
|
* @brief Sorts the elements in a range.
|
|
*
|
|
* Sorts the elements in a range using the given binary comparison function.
|
|
*
|
|
* @tparam It Type of random access iterator.
|
|
* @tparam Compare Type of comparison function object.
|
|
* @param first An iterator to the first element of the range to sort.
|
|
* @param last An iterator past the last element of the range to sort.
|
|
* @param compare A valid comparison function object.
|
|
*/
|
|
template<typename It, typename Compare = std::less<>>
|
|
void operator()(It first, It last, Compare compare = Compare{}) const {
|
|
if(first < last) {
|
|
for(auto it = first + 1; it < last; ++it) {
|
|
auto value = std::move(*it);
|
|
auto pre = it;
|
|
|
|
for(; pre > first && compare(value, *(pre - 1)); --pre) {
|
|
*pre = std::move(*(pre - 1));
|
|
}
|
|
|
|
*pre = std::move(value);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @brief Function object for performing LSD radix sort.
|
|
* @tparam Bit Number of bits processed per pass.
|
|
* @tparam N Maximum number of bits to sort.
|
|
*/
|
|
template<std::size_t Bit, std::size_t N>
|
|
struct radix_sort {
|
|
static_assert((N % Bit) == 0, "The maximum number of bits to sort must be a multiple of the number of bits processed per pass");
|
|
|
|
/**
|
|
* @brief Sorts the elements in a range.
|
|
*
|
|
* Sorts the elements in a range using the given _getter_ to access the
|
|
* actual data to be sorted.
|
|
*
|
|
* This implementation is inspired by the online book
|
|
* [Physically Based Rendering](http://www.pbr-book.org/3ed-2018/Primitives_and_Intersection_Acceleration/Bounding_Volume_Hierarchies.html#RadixSort).
|
|
*
|
|
* @tparam It Type of random access iterator.
|
|
* @tparam Getter Type of _getter_ function object.
|
|
* @param first An iterator to the first element of the range to sort.
|
|
* @param last An iterator past the last element of the range to sort.
|
|
* @param getter A valid _getter_ function object.
|
|
*/
|
|
template<typename It, typename Getter = identity>
|
|
void operator()(It first, It last, Getter getter = Getter{}) const {
|
|
if(first < last) {
|
|
static constexpr auto mask = (1 << Bit) - 1;
|
|
static constexpr auto buckets = 1 << Bit;
|
|
static constexpr auto passes = N / Bit;
|
|
|
|
using value_type = typename std::iterator_traits<It>::value_type;
|
|
std::vector<value_type> aux(std::distance(first, last));
|
|
|
|
auto part = [getter = std::move(getter)](auto from, auto to, auto out, auto start) {
|
|
std::size_t index[buckets]{};
|
|
std::size_t count[buckets]{};
|
|
|
|
for(auto it = from; it != to; ++it) {
|
|
++count[(getter(*it) >> start) & mask];
|
|
}
|
|
|
|
for(std::size_t pos{}, end = buckets - 1u; pos < end; ++pos) {
|
|
index[pos + 1u] = index[pos] + count[pos];
|
|
}
|
|
|
|
for(auto it = from; it != to; ++it) {
|
|
out[index[(getter(*it) >> start) & mask]++] = std::move(*it);
|
|
}
|
|
};
|
|
|
|
for(std::size_t pass = 0; pass < (passes & ~1); pass += 2) {
|
|
part(first, last, aux.begin(), pass * Bit);
|
|
part(aux.begin(), aux.end(), first, (pass + 1) * Bit);
|
|
}
|
|
|
|
if constexpr(passes & 1) {
|
|
part(first, last, aux.begin(), (passes - 1) * Bit);
|
|
std::move(aux.begin(), aux.end(), first);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
} // namespace entt
|
|
|
|
#endif
|