random.h

Go to the documentation of this file.

 
#pragma once
#include <limits>
#include <optional>
#include <random>
#include "argument_null_exception.h"
#include "argument_out_of_range_exception.h"
#include "core_export.h"
#include "environment.h"
#include "object.h"
 
namespace xtd {
  class random : public object {
  public:
    random() : generator_(static_cast<uint32_t>(environment::tick_count().count())) {}
    
    explicit random(uint32_t seed) : generator_(seed + 1) {}
    
    explicit random(std::random_device& random_device) : generator_(random_device()) {}
    
    virtual int32_t next() const {return next(std::numeric_limits<int32_t>::max());}
    
    template<typename value_t>
    value_t next() const {return next(std::numeric_limits<value_t>::max());}
    
    virtual int32_t next(int32_t max_value) const {return next(0, max_value);}
    
    template<typename value_t>
    value_t next(value_t max_value) const {return next(0, max_value);}
 
    virtual int32_t next(int32_t min_value, int32_t max_value) const {
      if (min_value > max_value) throw argument_out_of_range_exception(current_stack_frame_);
      if (min_value == max_value) return min_value;
      return min_value + static_cast<int32_t>(std::round(sample() * std::numeric_limits<int32_t>::max())) % ((max_value - 1) - min_value + 1);
    }
 
    template<typename value_t>
    value_t next(value_t min_value, value_t max_value) const {
      if (min_value > max_value) throw argument_out_of_range_exception(current_stack_frame_);
      if (min_value == max_value) return min_value;
      return min_value + static_cast<value_t>(std::round(sample() * std::numeric_limits<value_t>::max())) % ((max_value - 1) - min_value + 1);
    }
 
    virtual void next_bytes(std::vector<uint8_t>& buffer) const {next_bytes(buffer.data(), buffer.size());}
 
    virtual void next_bytes(uint8_t* buffer, size_t buffer_size) const {
      if (buffer == nullptr) throw argument_null_exception(current_stack_frame_);
      for (size_t index = 0; index < buffer_size; index++)
        buffer[index] = next<uint8_t>(0, std::numeric_limits<uint8_t>::max());
    }
 
    template<typename value_t>
    void next_values(std::vector<value_t>& buffer) const {next_values(buffer.data(), buffer.size());}
    
    template<typename value_t>
    void next_values(value_t* buffer, size_t buffer_size) const {
      if (buffer == nullptr) throw argument_null_exception(current_stack_frame_);
      for (size_t index = 0; index < buffer_size; index++)
      buffer[index] = next<value_t>(0, std::numeric_limits<value_t>::max());
    }
 
    virtual double next_double() const{return sample();}
    
  protected:
    virtual double sample() const {
      static std::uniform_real_distribution<> distribution_(0, 1);
      return distribution_(generator_);
    }
 
  private:
    mutable std::default_random_engine generator_;
  };
}