Как правильно заполнить std :: mt19937 с помощью std :: chrono :: high_resolution_clock внутри класса?

Question

Прежде всего, всем привет!Это мой первый вопрос здесь, так что я надеюсь, что я не облажался.Я много гуглил, прежде чем писать здесь.Я новичок в кодировании, в C ++, и я изучаю его самостоятельно.

Учитывая, что мне сказали, что это хорошая практика (я, вероятно, ошибаюсь здесь), начинать произвольный движок только один раз,Каков правильный / лучший / более эффективный способ использования std::mt19937 из случайной стандартной библиотеки внутри класса, засеянного std::chrono::high_resolution_clock::now().time_since_epoch().count() из стандартной библиотеки хроно?

Я хочу использовать это значение хроно, потому чтоон меняется очень быстро и порождает ужасное число.Я никогда не рассматривал std::random_device, потому что я думаю, что это довольно теневое.Я, вероятно, снова ошибаюсь.

РЕДАКТИРОВАТЬ: В большинстве случаев я пишу код и учусь на своем телефоне Android с IDE C4Droid, потому что у меня не так много свободного времени, чтобы сидеть направильный компьютер, поэтому я думаю, что std::random_device не очень надежен.

Я успешно это сделал, прежде чем знал, что такое класс, но сейчас я изучаю классы и много пробовал иошибка (помещая static_casts везде, пробуя const, static и т. д., потому что код всегда выдавал ошибки), чтобы сделать это:

class Deck
{
private:
    std::array<Card, 52> m_card;
    const int m_seed {static_cast<int>(std::chrono::high_resolution_clock::now().time_since_epoch().count())};

    std::mt19937 m_rng {m_seed};

    int rng(int min, int max)
    {
        std::uniform_int_distribution<> rng{min, max};
    return rng(m_rng);
    }

    void swapCard(Card &a, Card &b)
    {
        Card temp {a};
        a = b;
        b = temp;
    }

public:

    Deck()
    {
        int index{0};
        for (int iii {0}; iii < Card::CS_MAX; ++iii)
        {
            for (int jjj {0}; jjj < Card::CR_MAX; ++jjj)
            {
                m_card[index] = Card(static_cast<Card::CardSuit>(iii), static_cast<Card::CardRank>(jjj));
                ++index;
            }
        }
    }

    void printDeck() const
    {
    for (int iii {0}; iii < 52; ++iii)
        {
            m_card[iii].printCard();
            if (((iii + 1) % 13 == 0) && iii != 0)
                std::cout << '\n';
            else
                std::cout << ' ';
        }
    }

    void shuffleDeck(int xTimes = 1)
    {
        for (int iii {0}; iii < xTimes; ++iii)
        {
            for (int jjj {0}; jjj < 52; ++jjj)
            {
                swapCard(m_card[jjj], m_card[rng(0, 51)]);
            }
        }
    }

};

Это работает, но я не знаю, правильно ли этоделать это.Кроме того, мне сказали, что переменные, которые никогда не меняются, можно сделать статическими, чтобы делиться ими со всеми объектами класса, но я не могу сделать статический m_seed ...

Я уверен, что есть более эффективный способделая это.Ребята, вы можете помочь?

Answer 1

Мне сказали, что хорошей практикой является запуск любого случайного механизма только один раз

Звучит как здравый совет. Я хотел бы добавить, что вы должны иметь ровно один генератор на поток, так как создание и заполнение требует времени, а стандартные генераторы не безопасны для потоков.

Я думаю std::random_device не очень надежно

Он должен быть в состоянии сказать вам, если это через его функцию entropy(). Нулевая энтропия означает, что ее пул энтропии пуст или даже не существует. В последнем случае вы получите псевдослучайные числа.

Как правильно ...

Прочитав ссылки в комментариях и некоторые другие советы, я собрал вот что:

• Создайте SeedSequence класс, который создает столько начальных значений, сколько требуется генератору. Если энтропия в std::random_device равна нулю, объедините ее как можно лучше с другим источником. Я думаю, что хэшированные time_point выборки, взятые некоторое время друг от друга, могут работать в комбинации с rd(), поскольку 1 измененный бит во входном значении в идеале должен изменять половину битов в хэшированном значении.
• Создание общего генератора, который автоматически создается и заполняется при запросе от (нового) потока, поскольку генераторы не являются поточно-ориентированными.
• Создание шаблонов распространения, которые наследуются от генератора, чтобы все распределения в одном потоке использовали один и тот же генератор.
• Не создавайте экземпляры дистрибутива более, чем необходимо. Если вы часто используете один и тот же дистрибутив, сохраните его.

Вот попытка сделать это с комментариями в коде:

#include <iostream>
#include <chrono>
#include <climits>
#include <functional>
#include <iterator>
#include <random>
#include <thread>
#include <type_traits>
#include <utility>

//----------------------------------------------------------------------------------
// sexmex - A hash function kindly borrowed from Pelle Evensens yet to be published
// work: http://mostlymangling.blogspot.com/
//
// g++ 8.3.1: std::hash<Integer-type> lets the value through as-is (identity)
//            so I'll use this to create proper hash values instead.
template<typename Out = size_t, typename In>
inline std::enable_if_t<sizeof(In) * CHAR_BIT <= 64 &&
                            std::numeric_limits<Out>::is_integer &&
                            std::numeric_limits<In>::is_integer,
                        Out>
sexmex(In v) {
    uint64_t v2 = static_cast<uint64_t>(v); // cast away signedness
    v2 ^= (v2 >> 20) ^ (v2 >> 37) ^ (v2 >> 51);
    v2 *= 0xA54FF53A5F1D36F1ULL; // Fractional part of sqrt(7)
    v2 ^= (v2 >> 20) ^ (v2 >> 37) ^ (v2 >> 51);
    v2 *= 0x510E527FADE682D1ULL; // Fractional part of sqrt(11)
    v2 ^= (v2 >> 20) ^ (v2 >> 37) ^ (v2 >> 51);
    // Discard the high bits if Out is < 64 bits. This particular hash function
    // has not shown any weaknesses in the lower bits in any widely known test
    // suites yet.
    return static_cast<Out>(v2);
}
//----------------------------------------------------------------------------------
class seeder {
public:
    using result_type = std::uint_least32_t;

    // function called by the generator on construction to fill its internal state
    template<class RandomIt>
    void generate(RandomIt Begin, RandomIt End) const noexcept {
        using seed_t = std::remove_reference_t<decltype(*Begin)>;
        std::random_device rd{};

        if(rd.entropy() == 0.) { // check entropy
            // zero entropy, add some
            constexpr auto min = std::chrono::high_resolution_clock::duration::min();
            std::vector<seed_t> food_for_generator(
                static_cast<size_t>(std::distance(Begin, End)));

            for(int stiring = 0; stiring < 10; ++stiring) {
                for(auto& food : food_for_generator) {
                    // sleep a little to ensure a new clock count each iteration
                    std::this_thread::sleep_for(min);
                    std::this_thread::sleep_for(min);
                    auto cc = std::chrono::high_resolution_clock::now()
                                  .time_since_epoch()
                                  .count();
                    food ^= sexmex<seed_t>(cc);
                    food ^= sexmex<seed_t>(rd());
                }
                stir_buffer(food_for_generator);
            }

            // seed the generator
            for(auto f = food_for_generator.begin(); Begin != End; ++f, ++Begin)
                *Begin = *f;

        } else {
            // we got entropy, use random_device almost as-is but make sure
            // values from rd() becomes seed_t's number of bits and unbiased
            // via sexmex.
            //
            // seed the generator
            for(; Begin != End; ++Begin) *Begin = sexmex<seed_t>(rd());
        }
    }

private:
    template<typename SeedType>
    inline void stir_buffer(std::vector<SeedType>& buf) const noexcept {
        for(size_t i = 0; i < buf.size() * 2; ++i) {
            buf[i % buf.size()] += static_cast<SeedType>(
                sexmex(buf[(i + buf.size() - 1) % buf.size()] + i));
        }
    }
};
//----------------------------------------------------------------------------------
struct shared_generator {
    // we want one instance shared between all instances of uniform_dist per thread
    static thread_local seeder ss;
    static thread_local std::mt19937 generator;
};

thread_local seeder shared_generator::ss{};
thread_local std::mt19937 shared_generator::generator(ss);
//----------------------------------------------------------------------------------
// a distribution template for uniform distributions, both int and real
template<typename T>
class uniform_dist : shared_generator {
public:
    uniform_dist(T low, T high) : distribution(low, high) {}

    // make instances callable
    inline T operator()() { return distribution(generator); }

private:
    template<class D>
    using dist_t =
        std::conditional_t<std::is_integral_v<D>, std::uniform_int_distribution<D>,
                           std::uniform_real_distribution<D>>;

    dist_t<T> distribution;
};
//----------------------------------------------------------------------------------
void thread_func() {
    uniform_dist<int> something(0, 10);
    for(int i = 0; i < 10; ++i) std::cout << something() << "\n";
}

int main() {
    // all distributions sharing the same generator:
    uniform_dist<size_t> card_picker(0, 51);
    uniform_dist<int16_t> other(-32768, 32767);
    uniform_dist<float> fd(-1000.f, 1000.f);
    uniform_dist<double> dd(-1., 1.);
    for(int i = 0; i < 10; ++i) std::cout << card_picker() << "\n";
    std::cout << "--\n";
    for(int i = 0; i < 10; ++i) std::cout << other() << "\n";
    std::cout << "--\n";
    for(int i = 0; i < 10; ++i) std::cout << fd() << "\n";
    std::cout << "--\n";
    for(int i = 0; i < 10; ++i) std::cout << dd() << "\n";
    // in the thread function, a new generator will be created and seeded.
    std::thread t(thread_func);
    t.join();
}