random.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "argument_null_exception.hpp"
#include "argument_out_of_range_exception.hpp"
#include "box_integer.hpp"
#include "core_export.hpp"
#include "environment.hpp"
#include "math.hpp"
#include "object.hpp"
#include "optional.hpp"
#include <limits>
#include <random>
 
namespace xtd {
  class random : public object {
  public:
    
    random();
    
    explicit random(uint32 seed);
    
    explicit random(std::random_device& random_device);
    
    random(random&&) = default;
    random(const random&) = default;
    random& operator =(const random&) = default;
    
    
    std::default_random_engine generator() const noexcept;
    
    
    virtual int32 next() const;
    
    template<typename value_t>
    value_t next() const {
      return next(xtd::box_integer<value_t>::max_value);
    }
    
    virtual int32 next(int32 max_value) const;
    
    template<typename value_t>
    value_t next(value_t max_value) const {
      return static_cast<value_t>(next(value_t {}, max_value));
    }
    
    virtual int32 next(int32 min_value, int32 max_value) const;
    
    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 {};
      if (min_value == max_value) return min_value;
      return min_value + static_cast<value_t>(math::round(sample() * xtd::box_integer<value_t>::max_value)) % ((max_value - 1) - min_value + 1);
    }
    
    decimal next(decimal max_value) const;
    double next(double max_value) const;
    float next(float max_value) const;
    decimal next(decimal min_value, decimal max_value) const;
    double next(double min_value, double max_value) const;
    float next(float min_value, float max_value) const;
 
    virtual void next_bytes(std::vector<xtd::byte>& buffer) const;
    
    virtual void next_bytes(xtd::byte* buffer, size_t buffer_size) const;
    
    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 {};
      for (size_t index = 0; index < buffer_size; index++)
        buffer[index] = next<value_t>(0, xtd::box_integer<value_t>::max_value);
    }
    
    virtual double next_double() const;
    
  protected:
    virtual double sample() const;
    
  private:
    mutable std::default_random_engine generator_;
  };
}