Sort.hpp

Go to the documentation of this file.

#ifndef SOLIDUTILS_SORT_HPP
#define SOLIDUTILS_SORT_HPP

#include "VectorMath.hpp"
#include "Random.hpp"

#include <memory>
#include <vector>
#include <algorithm>

namespace sl
{

class Sort
{
  public:
    template<typename K, typename I>
    static std::unique_ptr<I[]> fixedKeys(
        K const * const keys,
        size_t const num)
    {
      static_assert(std::is_integral<K>::value, "Must by integral type.");
      static_assert(std::is_integral<I>::value, "Must by integral type.");

      std::vector<size_t> counts(num+1,0);
      counts.reserve(num);

      /* avoid having to do offsets in each iteration */
      for (size_t i = 0; i < num; ++i) {
        ++counts[keys[i]];
      }

      sl::VectorMath::prefixSumExclusive(counts.data(), counts.size());

      std::unique_ptr<I[]> out(new I[num]);

      for (size_t i = 0; i < num; ++i) {
        out[counts[keys[i]]++] = i;
      }

      return out;
    }

    template<typename K, typename I, typename URBG>
    static std::unique_ptr<I[]> fixedKeysRandom(
        K const * const keys,
        size_t const num,
        URBG&& rng)
    {
      static_assert(std::is_integral<K>::value, "Must by integral type.");
      static_assert(std::is_integral<I>::value, "Must by integral type.");

      std::vector<size_t> counts(num+1,0);
      counts.reserve(num);

      /* avoid having to do offsets in each iteration */
      for (size_t i = 0; i < num; ++i) {
        ++counts[keys[i]];
      }

      sl::VectorMath::prefixSumExclusive(counts.data(), counts.size());

      std::unique_ptr<I[]> out(new I[num]);

      for (size_t i = 0; i < num; ++i) {
        out[counts[keys[i]]++] = i;
      }

      // randomize each bucket
      size_t start = 0;
      for (size_t i = 0; start < num; ++i) {
        sl::Random::pseudoShuffle(out.get()+start, counts[i] - start, rng);
        start = counts[i];
      }

      return out;
    }


};


}

#endif