random_generator.hpp

Go to the documentation of this file.

// Copyright (c) 2013-2018 Commissariat à l'énergie atomique et aux énergies alternatives (CEA)
// Copyright (c) 2013-2018 Centre national de la recherche scientifique (CNRS)
// Copyright (c) 2018-2020 Simons Foundation
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You may obtain a copy of the License at
//     https://www.gnu.org/licenses/gpl-3.0.txt
//
// Authors: Michel Ferrero, Olivier Parcollet, Nils Wentzell

 
#pragma once
 
#include <h5/h5.hpp>
 
#include <cassert>
#include <cmath>
#include <concepts>
#include <cstdint>
#include <iostream>
#include <memory>
#include <string>
#include <sstream>
#include <utility>
#include <vector>
 
namespace triqs::mc_tools {


  class random_generator {
    private:
    // RNG concept defines the interface for RNGs.
    struct rng_concept {
      virtual ~rng_concept()                                 = default;
      virtual double operator()()                            = 0;
      virtual void refill(std::vector<double> &)             = 0;
      virtual std::ostream &to_ostream(std::ostream &) const = 0;
      virtual std::istream &from_istream(std::istream &)     = 0;
    };
 
    // RNG model implements the RNG concept by calling the appropriate methods of the type erased object.
    template <typename T> struct rng_model : public rng_concept {
      T rng_;
      rng_model(T rng) : rng_{std::move(rng)} {}
      double operator()() override { return rng_(); }
      void refill(std::vector<double> &buffer) override {
        for (auto &x : buffer) x = rng_();
      }
      std::ostream &to_ostream(std::ostream &os) const override {
        os << rng_.engine();
        return os;
      }
      std::istream &from_istream(std::istream &is) override {
        is >> rng_.engine();
        return is;
      }
    };
 
    public:
    static constexpr std::uint32_t default_seed = 198;

    random_generator() : random_generator("mt19937", default_seed) {}

    random_generator(std::string name, std::uint32_t seed, std::size_t buffer_size = 1000);

    random_generator(random_generator const &) = delete;

    random_generator(random_generator &&) = default;

    random_generator &operator=(random_generator &&) = default;

    [[nodiscard]] std::string name() const { return name_; }

    template <typename T>
      requires(std::integral<T>)
    T operator()(T i) {
      return (i == 1 ? 0 : static_cast<T>(std::floor(i * this->operator()())));
    }

    [[nodiscard]] double preview() {
      if (idx_ > buffer_.size() - 1) refill();
      return buffer_[idx_];
    }

    double operator()() {
      if (idx_ > buffer_.size() - 1) refill();
      return buffer_[idx_++];
    }

    double operator()(double b) { return b * (this->operator()()); }

    double operator()(double a, double b) {
      assert(b > a);
      return a + (b - a) * (this->operator()());
    }

    [[nodiscard]] static std::string hdf5_format() { return "random_generator"; }

    friend void h5_write(h5::group g, std::string const &name, random_generator const &rng) {
      auto gr = g.create_group(name);
      h5::write_hdf5_format(gr, rng); // NOLINT (downcasting to base class)
      h5::write(gr, "name", rng.name_);
      h5::write(gr, "buffer", rng.buffer_);
      h5::write(gr, "idx", rng.idx_);
      std::ostringstream os;
      rng.ptr_->to_ostream(os);
      h5::write(gr, "rng", os.str());
    }

    friend void h5_read(h5::group g, std::string const &name, random_generator &rng) {
      auto gr = g.open_group(name);
      h5::assert_hdf5_format(gr, rng); // NOLINT (downcasting to base class)
      h5::read(gr, "name", rng.name_);
      h5::read(gr, "buffer", rng.buffer_);
      h5::read(gr, "idx", rng.idx_);
      rng.initialize_rng(rng.name_, default_seed);
      std::string rng_state;
      h5::read(gr, "rng", rng_state);
      std::istringstream is{rng_state};
      rng.ptr_->from_istream(is);
    }
 
    private:
    // Refill the buffer.
    void refill() {
      ptr_->refill(buffer_);
      idx_ = 0;
    }
 
    // Initialize the RNG.
    void initialize_rng(std::string const &name, std::uint32_t seed);
 
    private:
    std::unique_ptr<rng_concept> ptr_;
    size_t idx_{0};
    std::vector<double> buffer_;
    std::string name_;
  };

  [[nodiscard]] std::string random_generator_names(std::string const &sep = " ");

  [[nodiscard]] std::vector<std::string> random_generator_names_list();

 
} // namespace triqs::mc_tools