random.hpp

Go to the documentation of this file.

#pragma once
 
#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(xtd::uint32 seed);
    
    explicit random(std::random_device& random_device);
    
    random(random&&) = default;
    random(const random&) = default;
    random& operator =(const random&) = default;
    
    
    [[nodiscard]] auto generator() const noexcept -> const std::default_random_engine&;
    [[nodiscard]] auto generator() noexcept -> std::default_random_engine&;
    
    
    template<typename value_t>
    [[nodiscard]] auto get_items(const xtd::read_only_span<value_t>& choices, xtd::usize length) -> xtd::array<value_t> {
      auto result = array<value_t>(length);
      auto span_result = span<value_t>(result);
      get_items(choices, span_result);
      return result;
    }

    template<typename value_t>
    [[nodiscard]] auto get_items(const xtd::array<value_t>& choices, xtd::usize length) -> xtd::array<value_t> {
      return get_items(read_only_span<value_t>(choices), length);
    }

    template<typename value_t>
    auto get_items(const xtd::read_only_span<value_t>& choices, xtd::span<value_t>& destination) -> void {
      for (auto& item : destination)
        item = choices[next(choices.length())];
    }
    
    [[nodiscard]] virtual auto next() const -> xtd::int32;
    template<typename value_t>
    [[nodiscard]] auto next() const -> value_t {
      return next(xtd::box_integer<value_t>::max_value);
    }
    
    [[nodiscard]] virtual auto next(xtd::int32 max_value) const -> xtd::int32;
    template<typename value_t>
    [[nodiscard]] auto next(value_t max_value) const -> value_t {
      return static_cast<value_t>(next(value_t {}, max_value));
    }
    
    [[nodiscard]] virtual auto next(xtd::int32 min_value, xtd::int32 max_value) const -> xtd::int32;
    template<typename value_t>
    [[nodiscard]] auto next(value_t min_value, value_t max_value) const -> value_t {
      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)));
    }
    
    template<xtd::boolean>
    [[nodiscard]] auto next() const -> xtd::boolean {return static_cast<xtd::boolean>(next(0, 2));}
    [[nodiscard]] auto next(xtd::boolean max_value) const -> xtd::boolean;
    [[nodiscard]] auto next(xtd::decimal max_value) const -> xtd::decimal;
    [[nodiscard]] auto next(double max_value) const -> double;
    [[nodiscard]] auto next(xtd::single max_value) const -> xtd::single;
    [[nodiscard]] auto next(xtd::boolean min_value, xtd::boolean max_value) const -> xtd::boolean;
    [[nodiscard]] auto next(xtd::decimal min_value, xtd::decimal max_value) const -> xtd::decimal;
    [[nodiscard]] auto next(double min_value, double max_value) const -> double;
    [[nodiscard]] auto next(xtd::single min_value, xtd::single max_value) const -> xtd::single;
    
    
    [[nodiscard]] virtual auto next_byte() const -> xtd::byte;
    [[nodiscard]] virtual auto next_byte(xtd::byte max_value) const -> xtd::byte;
    [[nodiscard]] virtual auto next_byte(xtd::byte min_value, xtd::byte max_value) const -> xtd::byte;

    virtual auto next_bytes(xtd::span<xtd::byte>& buffer) const -> void;
    virtual auto next_bytes(xtd::array<xtd::byte>& buffer) const -> void;
    
    [[nodiscard]] virtual auto next_double() const -> double;
    
    template<typename value_t>
    auto next_values(xtd::span<value_t>& buffer) const -> void {
      for (auto index = 0_z; index < buffer.length(); ++index)
        buffer[index] = next<value_t>();
    }
    
    template<typename value_t>
    auto next_values(xtd::array<value_t>& buffer) const -> void {
      auto span_buffer = span<value_t> {buffer};
      next_values(span_buffer);
    }
    
    [[nodiscard]] virtual auto next_int64() const -> xtd::int64;
    [[nodiscard]] virtual auto next_int64(int64 max_value) const -> xtd::int64;
    [[nodiscard]] virtual auto next_int64(int64 min_value, int64 max_value) const -> xtd::int64;
    
    [[nodiscard]] virtual auto next_single() const -> xtd::single;
    
    template<typename value_t>
    auto shuffle(xtd::span<value_t>& values) const -> xtd::span<value_t>& {
      for (auto index = 0_z; index < values.length() - 1; ++index)
        std::swap(values[index], values[next(index, values.length())]);
      return values;
    }

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

    template<typename collection_t>
    auto shuffle(const collection_t& values) const -> collection_t {
      auto result = values;
      shuffle(result);
      return result;
    }

    
  protected:
    [[nodiscard]] virtual auto sample() const -> double;
    
  private:
    mutable std::default_random_engine generator_;
  };
}