Random.hpp

Go to the documentation of this file.

#ifndef SOLIDUTILS_INCLUDE_RANDOM_HPP
#define SOLIDUTILS_INCLUDE_RANDOM_HPP


#include "Debug.hpp"
#include "FastIntDistribution.hpp"

#include <cstddef>
#include <algorithm>
#include <type_traits>



namespace sl
{

class Random
{
  public:
    template<typename T, typename URBG>
    static T inRange(
        T const min,
        T const max,
        URBG&& rng) noexcept
    {
      T const range = max - min;
      return min + static_cast<T>(static_cast<uint64_t>(rng()) % range);
    }


    template <typename T, typename URBG>
    static void fillWithRange(
        T * const data,
        size_t const num,
        T const min,
        T const max,
        URBG&& rng) noexcept
    {
      if (min == max) {
        for (size_t i = 0; i < num; ++i) {
          data[i] = min;
        }
      } else {
        for (size_t i = 0; i < num; ++i) {
          data[i] = inRange(min, max, rng);
        }
      }
    }


    template <typename T, typename URBG>
    static void fillWithPerm(
        T * const data,
        size_t const num,
        T const offset,
        URBG&& rng) noexcept
    {
      for (size_t i = 0; i < num; ++i) {
        data[i] = static_cast<T>(i)+offset;
      }

      pseudoShuffle(data, num, rng);
    }

    template <typename T, typename URBG>
    static void pseudoShuffle(
        T * const data,
        size_t const num,
        URBG&& rng) noexcept
    {
      constexpr size_t swapSize = 8;
      constexpr size_t minSize = 64;

      if (num < minSize) {
        // for small arrays, resort to std::shuffle
        std::shuffle(data, data+num, rng);
      } else {
        FastIntDistribution<size_t> indexDist(0, num-swapSize);
        FastIntDistribution<int> swapDist(0, 4);

        // The below swapping is originally based on the algorithm used in
        // `randArrayPermute()` function in George Karypis's GKLib.

        // perform several network swaps
        for (size_t swap = 0; swap < num/swapSize; ++swap) {
          size_t const start = indexDist(rng);
          size_t const end = indexDist(rng);
          int const swapSet = swapDist(rng);
          switch (swapSet) {
            case 0:
              std::swap(data[start], data[end+1]);
              std::swap(data[start+1], data[end+4]);
              std::swap(data[start+2], data[end+7]);
              std::swap(data[start+3], data[end+3]);
              std::swap(data[start+4], data[end+2]);
              std::swap(data[start+5], data[end+6]);
              std::swap(data[start+6], data[end]);
              std::swap(data[start+7], data[end+5]);
              break;
            case 1:
              std::swap(data[start], data[end+5]);
              std::swap(data[start+1], data[end+3]);
              std::swap(data[start+2], data[end+1]);
              std::swap(data[start+3], data[end+6]);
              std::swap(data[start+4], data[end]);
              std::swap(data[start+5], data[end+7]);
              std::swap(data[start+6], data[end+2]);
              std::swap(data[start+7], data[end+4]);
              break;
            case 2:
              std::swap(data[start], data[end+3]);
              std::swap(data[start+1], data[end+5]);
              std::swap(data[start+2], data[end+6]);
              std::swap(data[start+3], data[end+1]);
              std::swap(data[start+4], data[end+2]);
              std::swap(data[start+5], data[end]);
              std::swap(data[start+6], data[end+4]);
              std::swap(data[start+7], data[end+7]);
              break;
            case 3:
              std::swap(data[start], data[end+7]);
              std::swap(data[start+1], data[end]);
              std::swap(data[start+2], data[end+2]);
              std::swap(data[start+3], data[end+3]);
              std::swap(data[start+4], data[end+4]);
              std::swap(data[start+5], data[end+1]);
              std::swap(data[start+6], data[end+6]);
              std::swap(data[start+7], data[end+5]);
              break;
          }
        }
      }
    }




};


}


#endif