<random> generiert unter Linux dieselbe Nummer, jedoch nicht unter Windows

Der folgende Code soll eine Liste von fünf Pseudozufallszahlen im Intervall [1.100] generieren. Ich setze das default_random_enginemit time(0), was die Systemzeit in Unix-Zeit zurückgibt . Wenn ich dieses Programm unter Windows 7 mit Microsoft Visual Studio 2013 kompiliere und ausführe, funktioniert es wie erwartet (siehe unten). Wenn ich dies in Arch Linux mit dem g ++ - Compiler mache, verhält es sich jedoch seltsam.

Unter Linux werden jedes Mal 5 Zahlen generiert. Die letzten 4 Zahlen sind bei jeder Ausführung unterschiedlich (wie es häufig der Fall ist), aber die erste Zahl bleibt gleich.

Beispielausgabe von 5 Ausführungen unter Windows und 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

Hinzu kommt, dass diese erste Zahl unter Linux regelmäßig um eins erhöht wird. Nachdem ich die obigen Ausgaben erhalten hatte, wartete ich ungefähr 30 Minuten und versuchte erneut festzustellen, dass sich die erste Zahl geändert hatte und nun immer als 26 generiert wurde. Sie wurde in regelmäßigen Abständen um 1 erhöht und liegt nun bei 32. Es scheint zu entsprechen mit dem sich ändernden Wert von time(0).

Warum ändert sich die erste Zahl selten über Läufe hinweg und erhöht sich dann, wenn dies der Fall ist, um 1?

Der Code. Es druckt die 5 Zahlen und die Systemzeit sauber aus:

#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;
}

Folgendes ist los:

• default_random_enginein libstdc ++ (GCCs Standardbibliothek) ist minstd_rand0dies eine einfache lineare kongruente Engine:

  typedef linear_congruential_engine<uint_fast32_t, 16807, 0, 2147483647> minstd_rand0;

• Die Art und Weise, wie diese Engine Zufallszahlen generiert, ist x _{i + 1} = (16807x _i + 0) mod 2147483647.

• Wenn sich die Samen um 1 unterscheiden, unterscheidet sich die erste generierte Zahl daher meistens um 16807.

• Die Reichweite dieses Generators beträgt [1, 2147483646]. Libstdc ++ uniform_int_distributionordnet es im Wesentlichen einer Ganzzahl im Bereich [1, 100] zu: Generieren Sie eine Zahl n. Wenn die Anzahl nicht größer als 2147483600 ist, kehren Sie zurück (n - 1) / 21474836 + 1. Andernfalls versuchen Sie es erneut mit einer neuen Nummer.

  Es sollte leicht zu erkennen sein, dass in den allermeisten Fällen zwei ns, die sich nur um 16807 unterscheiden, nach diesem Verfahren die gleiche Zahl in [1, 100] ergeben. Tatsächlich würde man erwarten, dass sich die generierte Zahl etwa alle 21474836/16807 = 1278 Sekunden oder 21,3 Minuten um eins erhöht, was ziemlich gut mit Ihren Beobachtungen übereinstimmt.

MSVCs default_random_engineist mt19937, die dieses Problem nicht haben.

Die std::default_random_engineImplementierung ist definiert. Verwenden Sie std::mt19937oder std::mt19937_64stattdessen.

Wenn std::timedie ctimeFunktionen nicht sehr genau sind, verwenden Sie <chrono>stattdessen die in der Kopfzeile definierten Typen :

#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;
}

Unter Linux ist die Zufallsfunktion keine Zufallsfunktion im probabilistischen Sinne, sondern ein Pseudozufallszahlengenerator. Es wird mit einem Samen gesalzen, und basierend auf diesem Samen sind die produzierten Zahlen pseudozufällig und gleichmäßig verteilt. Der Linux-Weg hat den Vorteil, dass bei der Gestaltung bestimmter Experimente unter Verwendung von Informationen aus Populationen die Wiederholung des Experiments mit bekannter Optimierung der Eingabeinformationen gemessen werden kann. Wenn das endgültige Programm für Tests im realen Leben bereit ist, kann das Salz (Seed) erstellt werden, indem der Benutzer aufgefordert wird, die Maus zu bewegen, die Mausbewegung mit einigen Tastenanschlägen zu mischen und seit Beginn von einen Strich Mikrosekundenzahlen hinzuzufügen das letzte Einschalten.

Windows-Zufallszahlen-Seed wird aus der Sammlung von Maus-, Tastatur-, Netzwerk- und Tageszeitnummern erhalten. Es ist nicht wiederholbar. Dieser Salzwert kann jedoch auf einen bekannten Samen zurückgesetzt werden, wenn, wie oben erwähnt, einer an der Gestaltung eines Experiments beteiligt ist.

Oh ja, Linux hat zwei Zufallszahlengeneratoren. Zum einen ist der Standardwert Modulo 32 Bit und zum anderen Modulo 64 Bit. Ihre Wahl hängt von den Genauigkeitsanforderungen und der Rechenzeit ab, die Sie für Ihre Tests oder die tatsächliche Verwendung benötigen.