Random.h

Go to the documentation of this file.

 
#pragma once
 
#include <algorithm>
#include <iterator>
#include <random>
#include <set>
 
#include "autopas/utils/ExceptionHandler.h"
 
namespace autopas {
 
class Random : public std::mt19937 {
 public:
  explicit Random(unsigned long seed = std::random_device()()) : std::mt19937(seed) {}
 
  Random(const Random &other) = delete;
 
  Random &operator=(const Random &other) = delete;
 
  template <class Iter>
  std::vector<typename std::iterator_traits<Iter>::value_type> uniformSample(Iter poolBegin, Iter poolEnd, size_t n) {
    if (poolBegin == poolEnd) {
      autopas::utils::ExceptionHandler::exception("Random.uniformSample: Cannot sample from empty set.");
    }
 
    std::vector<typename std::iterator_traits<Iter>::value_type> result;
    result.reserve(n);
 
    // copy the whole set until result is full
    while (result.size() < n) {
      result.insert(std::end(result), poolBegin, poolEnd);
    }
 
    // if too many elements added
    if (result.size() > n) {
      // randomize the last copy of the set
      size_t extra = result.size() - n;
      std::shuffle(std::end(result) - extra, std::end(result), *this);
 
      // truncate the rest
      result.resize(n);
    }
 
    // randomize the sample
    std::shuffle(std::begin(result), std::end(result), *this);
 
    return result;
  }
 
  std::vector<size_t> uniformSample(size_t min, size_t max, size_t n) {
    std::set<size_t> allAllowed;
    for (size_t i = min; i <= max; ++i) {
      allAllowed.insert(i);
    }
    return uniformSample(allAllowed.begin(), allAllowed.end(), n);
  }
 
  template <class Container>
  auto pickRandom(const Container &pool) {
    std::uniform_int_distribution<size_t> distr(0ul, pool.size() - 1ul);
    size_t pos = distr(*this);
 
    auto it = std::begin(pool);
    std::advance(it, pos);
 
    return *it;
  }
 
  template <class T>
  std::set<T> randomSubset(std::set<T> pool, size_t n) {
    size_t size = std::min(n, pool.size());
 
    // create randomly shuffled vector of points to all elements in the pool
    std::vector<const T *> pointerVec;
    pointerVec.reserve(pool.size());
    for (const T &element : pool) {
      pointerVec.push_back(&element);
    }
    std::shuffle(pointerVec.begin(), pointerVec.end(), *this);
 
    // return first elements of the shuffled vector
    std::set<T> result;
    for (size_t i = 0; i < size; ++i) {
      result.insert(*pointerVec[i]);
    }
 
    return result;
  }
};
 
}  // namespace autopas