X-Git-Url: http://bilbo.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/9b56cfa026968b98b9b3665dbacbd4c472dc6cbc..b58b0ba2f6b92efa234677e19dd998346113504d:/src/xbt/random.cpp diff --git a/src/xbt/random.cpp b/src/xbt/random.cpp index 22d7591650..f63dd2f2d1 100644 --- a/src/xbt/random.cpp +++ b/src/xbt/random.cpp @@ -1,91 +1,158 @@ -/* Copyright (c) 2019-2020. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2019-2023. The SimGrid Team. All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ -#include "xbt/random.hpp" #include "xbt/asserts.h" +#include +#include #include -#include +#include +#include +#include +#include -namespace simgrid { -namespace xbt { -namespace random { -enum xbt_random_implem { XBT_RNG_xbt, XBT_RNG_std }; -static xbt_random_implem rng_implem = XBT_RNG_xbt; +XBT_LOG_EXTERNAL_CATEGORY(xbt); +XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_random, xbt, "Random"); -static std::mt19937 mt19937_gen; +namespace simgrid::xbt::random { -void set_implem_xbt() +bool Random::read_state(const std::string& filename) { - rng_implem = XBT_RNG_xbt; + std::ifstream file(filename); + file >> mt19937_gen; + file.close(); + if (file.fail()) + XBT_WARN("Could not save the RNG state to file %s.", filename.c_str()); + return not file.fail(); } -void set_implem_std() + +bool Random::write_state(const std::string& filename) const { - rng_implem = XBT_RNG_std; + std::ofstream file(filename); + file << mt19937_gen; + file.close(); + if (file.fail()) + XBT_WARN("Could not read the RNG state from file %s.", filename.c_str()); + return not file.fail(); } -void set_mersenne_seed(int seed) + +int StdRandom::uniform_int(int min, int max) { - mt19937_gen.seed(seed); + std::uniform_int_distribution dist(min, max); + return dist(mt19937_gen); } -int uniform_int(int min, int max) +double StdRandom::uniform_real(double min, double max) +{ + std::uniform_real_distribution dist(min, max); + return dist(mt19937_gen); +} + +double StdRandom::exponential(double lambda) { - if (rng_implem == XBT_RNG_std) { - std::uniform_int_distribution<> dist(min, max); - return dist(mt19937_gen); - } + std::exponential_distribution dist(lambda); + return dist(mt19937_gen); +} - unsigned long range = max - min + 1; - unsigned long value = mt19937_gen(); +double StdRandom::normal(double mean, double sd) +{ + std::normal_distribution dist(mean, sd); + return dist(mt19937_gen); +} + +int XbtRandom::uniform_int(int min, int max) +{ + // The casts to unsigned are here to ensure that the value of range is correctly calculated, even when greater than + // INT_MAX. See the corresponding unit tests for examples. + unsigned long range = static_cast(max) - static_cast(min); xbt_assert(min <= max, "The minimum value for the uniform integer distribution must not be greater than the maximum value"); - xbt_assert(range > 0, "Overflow in the uniform integer distribution, please use a smaller range."); - while (value >= decltype(mt19937_gen)::max() - decltype(mt19937_gen)::max() % range) { + xbt_assert(range <= decltype(mt19937_gen)::max(), + "Overflow in the uniform integer distribution, please use a smaller range."); + if (range == decltype(mt19937_gen)::max()) + return static_cast(mt19937_gen() + min); + + ++range; + unsigned long limit = decltype(mt19937_gen)::max() - decltype(mt19937_gen)::max() % range; + unsigned long value; + do { value = mt19937_gen(); - } - return value % range + min; + } while (value >= limit); + return static_cast(value % range + min); } -double uniform_real(double min, double max) +double XbtRandom::uniform_real(double min, double max) { - if (rng_implem == XBT_RNG_std) { - std::uniform_real_distribution<> dist(min, max); - return dist(mt19937_gen); - } - // This reuses Boost's uniform real distribution ideas - constexpr unsigned long divisor = decltype(mt19937_gen)::max() - decltype(mt19937_gen)::min() + 1; - unsigned long numerator = mt19937_gen() - decltype(mt19937_gen)::min(); - return min + (max - min) * numerator / divisor; + constexpr unsigned long divisor = decltype(mt19937_gen)::max() - decltype(mt19937_gen)::min(); + unsigned long numerator; + do { + numerator = mt19937_gen() - decltype(mt19937_gen)::min(); + } while (numerator == divisor); + return min + (max - min) * static_cast(numerator) / divisor; } -double exponential(double lambda) +double XbtRandom::exponential(double lambda) { - if (rng_implem == XBT_RNG_std) { - std::exponential_distribution<> dist(lambda); - return dist(mt19937_gen); - } - return -1.0 / lambda * log(uniform_real(0.0, 1.0)); } -double normal(double mean, double sd) +double XbtRandom::normal(double mean, double sd) { - if (rng_implem == XBT_RNG_std) { - std::normal_distribution<> dist(mean, sd); - return dist(mt19937_gen); - } - - double u1 = 0.0; - while (u1 < std::numeric_limits::min()) { + double u1; + do { u1 = uniform_real(0.0, 1.0); - } + } while (u1 < std::numeric_limits::min()); double u2 = uniform_real(0.0, 1.0); double z0 = sqrt(-2.0 * log(u1)) * cos(2.0 * M_PI * u2); return z0 * sd + mean; } -} // namespace random -} // namespace xbt -} // namespace simgrid +static std::unique_ptr default_random = std::make_unique(); + +void set_implem_xbt() +{ + default_random = std::make_unique(); +} +void set_implem_std() +{ + default_random = std::make_unique(); +} + +void set_mersenne_seed(int seed) +{ + default_random->set_seed(seed); +} + +bool read_mersenne_state(const std::string& filename) +{ + return default_random->read_state(filename); +} + +bool write_mersenne_state(const std::string& filename) +{ + return default_random->write_state(filename); +} + +int uniform_int(int min, int max) +{ + return default_random->uniform_int(min, max); +} + +double uniform_real(double min, double max) +{ + return default_random->uniform_real(min, max); +} + +double exponential(double lambda) +{ + return default_random->exponential(lambda); +} + +double normal(double mean, double sd) +{ + return default_random->normal(mean, sd); +} + +} // namespace simgrid::xbt::random