Mit boost::random und immer dieselbe Sequenz von zahlen

Ich habe den folgenden code:

Class B {

void generator()
{
    //creating random number generator
    boost::mt19937 randgen(static_cast<unsigned int>(std::time(0)));
    boost::normal_distribution<float> noise(0,1);
    boost::variate_generator<boost::mt19937, 
        boost::normal_distribution<float> > nD(randgen, noise);


    for (int i = 0; i < 100; i++)
    {
        value = nD();
        //graph each value
    }
}
};

Class A {

void someFunction()
{
    for(int i = 1; i <=3; i++)
    {
        std::shared_ptr<B> b;
        b.reset(new B());
        b->generator();
    }
}
};

Ich möchten, führen Sie den obigen code mehrere Male in schneller Folge zu produzieren, die mehrere Diagramme. Ich habe auch überprüft diese stackoverflow-Frage, die ist ähnlich, aber der VORBEHALT besagt, dass wenn die Zeit(0) verwendet wird und die member-Funktion heißt in rascher Folge, dann werden Sie wahrscheinlich immer noch erhalten die gleiche Sequenz von zahlen.

Wie könnte ich dieses problem umgehen?

EDIT: ich habe versucht, randgen statisch in der Klasse B, auch versucht, so dass es eine Globale variable in der Klasse A, aber jedes mal die 3 Grafiken sind immer noch die gleichen. Ich habe auch versucht das seeding von der GetSystemTime Millisekunden. Ich muss etwas fehlen.

Wenn es einen guten Grund, Sie zu verwenden, mt19937, anstatt einfach mit der Funktion " rand(), dann kann es ein guter Grund, um eine anständige Samen, auch. Es gibt web-services, die einen wirklich zufälligen Daten, sowie hardware, die Sie kaufen können. Könnten Sie diejenigen, die als Samen (in regelmäßigen Abständen), und verwenden Sie den PRNG, um Zeit zu sparen/Wartezeit zwischen re-Samen. en.wikipedia.org/wiki/...
Ich muss fehlt etwas - die Bearbeitung der Frage geben, größeres Bild.

InformationsquelleAutor Seth | 2010-02-03

  1. 6

    Eine Möglichkeit wäre, um nicht ein erneutes Seeding der Zufallszahlengenerator jedes mal, wenn Sie ausführen Ihres Codes.

    Erstellen des generator-und Samen-es einmal, dann einfach weiter zu verwenden.

    Das ist vorausgesetzt, Sie fordern, dass code mehrmals in der gleichen Ausführung. Wenn Sie mehrere Läufe (aber noch innerhalb der gleichen Sekunde), die Sie verwenden können, eine weitere abweichende Eigenschaft wie die Prozess-ID zu ändern den Samen.

    Alternativ kann man auch Plattform-abhängig, indem Sie entweder die Windows - GetSystemTime() Rückkehr eine SYSTEMTIME-Struktur mit seinen Elementen als Millisekunden, das Linux getTimeOfDay Rückkehr Anzahl der Mikrosekunden seit epoch.

    Windows:

    #include <windows.h>
SYSTEMTIME st;
GetSystemTime (&st);
//Use st.wSecond * 100 + st.wMillisecs to seed (0 thru 59999).

    Linux:

    #include <sys/time.h>
struct timeval tv;
gettimeofday (&tv, NULL);
//Use tv.tv_sec * 100 + (tv.tv_usec /1000) to seed (0 thru 59999).
    cool - mit GetSystemTime(). Ja ich mache mehrere Durchläufe und ich würde es vorziehen, nicht um eine Globale variable verwenden.
    dieser ist noch nicht für mich arbeiten, aus irgendeinem Grund, sogar mit Millisekunden

    InformationsquelleAutor paxdiablo

  2. 6

    Mit Boost.Random Sie können die Speicherung der Zustand des random number generator--zum Beispiel, können Sie es speichern in eine text-Datei. Dies geschieht mit streams.

    Zum Beispiel, die mit Ihrem code, nachdem Sie die Samen der generator und führen Sie es einmal, können Sie den Zustand sichern mit einem Ausgabe-stream wie folgt:

    std::ofstream generator_state_file("rng.saved");
generator_state_file << randgen;

    Dann später, wenn Sie ' ve erstellt einen neuen generator können Sie das laden der Staat wieder aus, die Datei mit der gegenüberliegenden stream:

    std::ifstream generator_state_file("rng.saved");
generator_state_file >> randgen;

    Und verwenden Sie dann den Staat zu generieren einige weitere zufällig ausgewählte zahlen, und dann wieder speichern Sie den Zustand, und so weiter und so weiter.

    Kann es auch möglich sein, speichern Sie den Staat zu einem std::string mit std::stringstream, wenn Sie nicht möchten, verwenden Sie eine Datei, aber ich habe nicht persönlich versucht, diese.

    Wow, ich wusste nicht, dass Sie das tun könnten. Genial.

    InformationsquelleAutor pdusen

  3. 4

    Nur eine einzige random number generator, so dass es nur einmal ausgesät:

    static boost::mt19937 randgen(static_cast<unsigned int>(std::time(0)));
    Ich verstehe das Prinzip. Allerdings, wenn ich es statisch in die Klasse. Ich würde denken, dass es nur einmal initialisieren. In meinem Fall, ich bin Instanziierung von mehreren Objekten, die die gleichen Zufallszahlen-source-code. Es produziert noch immer die gleiche Folge von zahlen, für jedes Objekt, wenn ich es statisch.

    InformationsquelleAutor R Samuel Klatchko

  4. 1

    Ersten Gedanken

    Unter unix könnten Sie versuchen, Lesen ein paar bytes aus /dev/random oder /dev/urandom für die Samen. Sie könnten auch versuchen, mit einer Kombination von time(0) + pid + statische Zähler (oder pseudo-random-Sequenz).

    Glaube ich auf windows, die Sie verwenden können QueryPerformanceCounter um den Wert der high-performance-timer-register.

    Ein anderer Gedanke:

    Könnten Sie erklären Ihre mt19937 prng als statische oder Globale, so dass Sie nie verlieren Ihren Status.

    Ein Dritter Gedanke:

    Sie wollen "führen Sie den obigen code mehrere Male in schneller Folge zu produzieren, die mehrere Graphen" pass in einem Diagramm index. (z.B. genGraph(int graphIndex) und kombinieren (addieren, xor, usw) mit der Ausgabe der Zeit(0). boost::mt19937 randgen(static_cast<unsigned int>(std::time(0) + graphIndex));

    InformationsquelleAutor KitsuneYMG

  5. 1

    Eine späte Antwort: zwei random-number-generator-Funktionen zum vergleichen von boost mit der standard-Methode.

    boost

    #include <boost/random.hpp>

//the code that uses boost is massively non-intuitive, complex and obfuscated

bool _boost_seeded_=false;

/*--------------------*/int
boostrand(int High, int Low)
{
    static boost::mt19937 random;
    if (!_boost_seeded_)
    {
        random = boost::mt19937(time(0));
        _boost_seeded_=true;
    }
    boost::uniform_int<> range(Low,High);
    boost::variate_generator<boost::mt19937&, boost::uniform_int<> > 
        getrandom(random, range);

    return getrandom();
}

    standard

    #include <cstdlib>
#include <time.h>

//standard code is straight-forward and quite understandable

bool _stdrand_seeded_=false;

/*--------------------*/int
stdrand(int High, int Low)
{
    if (!_stdrand_seeded_)
    {
        srand(time(0));
        _stdrand_seeded_=true;
    }
    return ((rand() % (High - Low + 1)) + Low);
}

    Die Ergebnisse aus beiden Funktionen sind vergleichsweise der gleiche "Zufall". Würde ich anwenden, das KISS-Prinzip.

    InformationsquelleAutor slashmais

  6. 0

    Wenn Sie nicht möchten, verwenden Sie nur einen generator, die Sie erstellen könnte ein generator mit seed(time(0)) und verwenden Sie dann, dass der generator als Samen in den anderen Generatoren.

    time(0) ist die Auflösung von 1 Sekunde. Verwenden Sie mehrere Male als Saatgut innerhalb kürzester Zeit schaffen wird, den gleichen generator.

    InformationsquelleAutor jpyllman

Schreibe einen Kommentar