<random> genera lo stesso numero in Linux, ma non in Windows

Question 1

Il codice seguente ha lo scopo di generare un elenco di cinque numeri pseudo-casuali nell'intervallo [1,100]. Semina il default_random_enginecon time(0), che restituisce l'ora di sistema in unix tempo . Quando compilo ed eseguo questo programma su Windows 7 utilizzando Microsoft Visual Studio 2013, funziona come previsto (vedi sotto). Quando lo faccio in Arch Linux con il compilatore g ++, tuttavia, si comporta in modo strano.

In Linux, verranno generati 5 numeri ogni volta. Gli ultimi 4 numeri saranno diversi ad ogni esecuzione (come spesso accade), ma il primo numero rimarrà lo stesso.

Output di esempio da 5 esecuzioni su Windows e Linux:

      | Windows:       | Linux:        
---------------------------------------
Run 1 | 54,01,91,73,68 | 25,38,40,42,21
Run 2 | 46,24,16,93,82 | 25,78,66,80,81
Run 3 | 86,36,33,63,05 | 25,17,93,17,40
Run 4 | 75,79,66,23,84 | 25,70,95,01,54
Run 5 | 64,36,32,44,85 | 25,09,22,38,13

Aggiungendo al mistero, quel primo numero aumenta periodicamente di uno su Linux. Dopo aver ottenuto le uscite di cui sopra, ho aspettato circa 30 minuti e ho provato di nuovo a scoprire che il 1 ° numero era cambiato e ora veniva sempre generato come 26. Ha continuato ad aumentare periodicamente di 1 ed ora è a 32. Sembra corrispondere con il valore variabile di time(0).

Perché il primo numero cambia raramente tra le serie e poi, quando lo fa, aumenta di 1?

Il codice. Stampa ordinatamente i 5 numeri e l'ora di sistema:

#include <iostream>
#include <random>
#include <time.h>

using namespace std;

int main()
{
    const int upper_bound = 100;
    const int lower_bound = 1;

    time_t system_time = time(0);    

    default_random_engine e(system_time);
    uniform_int_distribution<int> u(lower_bound, upper_bound);

    cout << '#' << '\t' << "system time" << endl
         << "-------------------" << endl;

    for (int counter = 1; counter <= 5; counter++)
    {
        int secret = u(e);
        cout << secret << '\t' << system_time << endl;
    }   

    system("pause");
    return 0;
}

Question 2

Ecco cosa sta succedendo:

default_random_enginein libstdc ++ (la libreria standard di GCC) è minstd_rand0, che è un semplice motore lineare congruente:
```
typedef linear_congruential_engine<uint_fast32_t, 16807, 0, 2147483647> minstd_rand0;
```
Il modo in cui questo motore genera numeri casuali è x _{i + 1} = (16807x _i + 0) mod 2147483647.
Pertanto, se i semi sono diversi di 1, il più delle volte il primo numero generato differirà di 16807.
La portata di questo generatore è [1, 2147483646]. Il modo in cui libstdc ++ uniform_int_distributionlo associa a un numero intero compreso nell'intervallo [1, 100] è essenzialmente questo: genera un numero n. Se il numero non è maggiore di 2147483600, restituisci (n - 1) / 21474836 + 1; in caso contrario, riprova con un nuovo numero.
Dovrebbe essere facile vedere che nella stragrande maggioranza dei casi, due ns che differiscono solo di 16807 produrranno lo stesso numero in [1, 100] con questa procedura. In effetti, ci si aspetterebbe che il numero generato aumenti di uno circa ogni 21474836/16807 = 1278 secondi o 21,3 minuti, il che concorda abbastanza bene con le tue osservazioni.

MSVC di default_random_engineè mt19937, che non ha questo problema.

Question 3

L' std::default_random_engineimplementazione è definita. Usa std::mt19937o std::mt19937_64invece.

Inoltre std::timee le ctimefunzioni non sono molto precise, usa invece i tipi definiti <chrono>nell'intestazione:

#include <iostream>
#include <random>
#include <chrono>

int main()
{
    const int upper_bound = 100;
    const int lower_bound = 1;

    auto t = std::chrono::high_resolution_clock::now().time_since_epoch().count();

    std::mt19937 e;
    e.seed(static_cast<unsigned int>(t)); //Seed engine with timed value.
    std::uniform_int_distribution<int> u(lower_bound, upper_bound);

    std::cout << '#' << '\t' << "system time" << std::endl
    << "-------------------" << std::endl;

    for (int counter = 1; counter <= 5; counter++)
    {
        int secret = u(e);

        std::cout << secret << '\t' << t << std::endl;
    }   

    system("pause");
    return 0;
}

Question 4

In Linux, la funzione casuale non è una funzione casuale nel senso probabilistico del modo, ma un generatore di numeri pseudo casuali. Viene salato con un seme e, in base a quel seme, i numeri che vengono prodotti sono pseudo casuali e distribuiti uniformemente. Il metodo Linux ha il vantaggio che nella progettazione di alcuni esperimenti che utilizzano informazioni provenienti da popolazioni, è possibile misurare la ripetizione dell'esperimento con modifiche note delle informazioni di input. Quando il programma finale è pronto per i test nella vita reale, il sale (seme) può essere creato chiedendo all'utente di muovere il mouse, mescolare il movimento del mouse con alcune sequenze di tasti e aggiungere un trattino di conteggi di microsecondi dall'inizio del l'ultima accensione.

Il seed dei numeri casuali di Windows è ottenuto dalla raccolta di numeri di mouse, tastiera, rete e ora del giorno. Non è ripetibile. Ma questo valore di sale può essere reimpostato su un seme noto, se, come menzionato sopra, si è coinvolti nella progettazione di un esperimento.

Oh sì, Linux ha due generatori di numeri casuali. Uno, il valore predefinito è modulo 32 bit e l'altro modulo 64 bit. La scelta dipende dalle esigenze di precisione e dalla quantità di tempo di elaborazione che si desidera consumare per i test o per l'utilizzo effettivo.