random.hpp

Go to the documentation of this file.

#pragma once
 
#include "argument_null_exception.hpp"
#include "argument_out_of_range_exception.hpp"
#include "array.hpp"
#include "box_integer.hpp"
#include "core_export.hpp"
#include "environment.hpp"
#include "math.hpp"
#include "numeric_literals.hpp"
#include "object.hpp"
#include "optional.hpp"
#include "span.hpp"
#include <algorithm>
#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;
    
    
    const std::default_random_engine& generator() const noexcept;
    std::default_random_engine& generator() noexcept;
    
    
    template<class value_t>
    xtd::array<value_t> get_items(const xtd::read_only_span<value_t>& choices, xtd::size length) {
      auto result = array<value_t>(length);
      auto span_result = span<value_t>(result);
      get_items(choices, span_result);
      return result;
    }
    xtd::array<value_t> get_items(const xtd::read_only_span<value_t>& choices, xtd::size length) {…}

    template<class value_t>
    xtd::array<value_t> get_items(const xtd::array<value_t>& choices, xtd::size length) {
      return get_items(read_only_span<value_t>(choices), length);
    }
    xtd::array<value_t> get_items(const xtd::array<value_t>& choices, xtd::size length) {…}

    template<class value_t>
    void get_items(const xtd::read_only_span<value_t>& choices, xtd::span<value_t>& destination) {
      for (auto& item : destination)
        item = choices[next(choices.size())];
    }
    void get_items(const xtd::read_only_span<value_t>& choices, xtd::span<value_t>& destination) {…}
    
    virtual int32 next() const;
    template<class value_t>
    value_t next() const {
      return next(xtd::box_integer<value_t>::max_value);
    }
    value_t next() const  {…}
    
    virtual int32 next(int32 max_value) const;
    template<class value_t>
    value_t next(value_t max_value) const {
      return static_cast<value_t>(next(value_t {}, max_value));
    }
    value_t next(value_t max_value) const  {…}
    
    virtual int32 next(int32 min_value, int32 max_value) const;
    template<class value_t>
    value_t next(value_t min_value, value_t max_value) const {
      if (min_value > max_value) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      if (min_value == max_value) return min_value;
      return min_value + static_cast<value_t>(math::round(sample() * (max_value - 1 - min_value)));
    }
    value_t next(value_t min_value, value_t max_value) const  {…}
    
    template<xtd::boolean>
    xtd::boolean next() const {return static_cast<xtd::boolean>(next(0, 2));}
    xtd::boolean next(xtd::boolean max_value) const;
    decimal next(decimal max_value) const;
    double next(double max_value) const;
    float next(float max_value) const;
    xtd::boolean next(xtd::boolean min_value, xtd::boolean 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(xtd::span<xtd::byte>& buffer) const;
    virtual void next_bytes(xtd::array<xtd::byte>& buffer) const;
    
    virtual double next_double() const;
    
    template<class value_t>
    void next_values(xtd::span<value_t>& buffer) const {
      for (auto index = 0_z; index < buffer.size(); ++index)
        buffer[index] = next<value_t>();
    }
    void next_values(xtd::span<value_t>& buffer) const  {…}
    
    template<class value_t>
    void next_values(xtd::array<value_t>& buffer) const {
      auto span_buffer = span<value_t> {buffer};
      next_values(span_buffer);
    }
    void next_values(xtd::array<value_t>& buffer) const  {…}
    
    virtual int64 next_int64() const;
    virtual int64 next_int64(int64 max_value) const;
    virtual int64 next_int64(int64 min_value, int64 max_value) const;
    
    virtual single next_single() const;
    
    template<class value_t>
    void shuffle(xtd::span<value_t>& values) const {
      for (auto index = 0_z; index < values.length() - 1; ++index)
        std::swap(values[index], values[next(index, values.length())]);
    }
    void shuffle(xtd::span<value_t>& values) const  {…}

    template<class collection_t>
    void shuffle(collection_t& values) const {
      auto span_values = span<typename collection_t::value_type> {values};
      shuffle(span_values);
    }
    void shuffle(collection_t& values) const  {…}

    
  protected:
    virtual double sample() const;
    
  private:
    mutable std::default_random_engine generator_;
  };
  class random : public object {…};
}