random.h

Go to the documentation of this file.

#pragma once
#include "argument_null_exception.h"
#include "argument_out_of_range_exception.h"
#include "core_export.h"
#include "environment.h"
#include "math.h"
#include "object.h"
#include "optional.h"
#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(std::numeric_limits<value_t>::max());
    }
    
    virtual int32 next(int32 max_value) const;
    
    template<typename value_t>
    value_t next(value_t max_value) const {
      return next(0, 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 {csf_};
      if (min_value == max_value) return min_value;
      return min_value + static_cast<value_t>(math::round(sample() * std::numeric_limits<value_t>::max())) % ((max_value - 1) - min_value + 1);
    }
    
    double next(decimal max_value) const;
    double next(double max_value) const;
    float next(float max_value) const;
    double 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 {csf_};
      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;
    
  protected:
    virtual double sample() const;
    
  private:
    mutable std::default_random_engine generator_;
  };
}