Verwendung von boost::random als RNG für std::random_shuffle

Question

Ich habe ein Programm, das den Zufallszahlengenerator mt19937 aus boost::random verwendet. Ich muss einen random_shuffle durchführen und möchte, dass die dafür generierten Zufallszahlen aus diesem gemeinsamen Zustand stammen, damit sie in Bezug auf die zuvor generierten Zahlen des Mersenne-Twisters deterministisch sein können.

Ich habe etwas Ähnliches versucht:

void foo(std::vector<unsigned> &vec, boost::mt19937 &state)
{
    struct bar {
        boost::mt19937 &_state;
        unsigned operator()(unsigned i) {
            boost::uniform_int<> rng(0, i - 1);
            return rng(_state);
        }
        bar(boost::mt19937 &state) : _state(state) {}
    } rand(state);

    std::random_shuffle(vec.begin(), vec.end(), rand);
}

Aber ich bekomme eine Vorlage Fehler Aufruf random_shuffle mit Rand. Dies funktioniert jedoch:

unsigned bar(unsigned i)
{
    boost::mt19937 no_state;
    boost::uniform_int<> rng(0, i - 1);
    return rng(no_state);
}
void foo(std::vector<unsigned> &vec, boost::mt19937 &state)
{
    std::random_shuffle(vec.begin(), vec.end(), bar);
}

Wahrscheinlich, weil es sich um einen tatsächlichen Funktionsaufruf handelt. Aber offensichtlich wird der Zustand des ursprünglichen Mersenne-Twisters nicht beibehalten. Woran liegt das? Gibt es eine Möglichkeit, das zu tun, was ich versuche, ohne globale Variablen zu tun?

Answer 1

In den Kommentaren bat Robert Gould um eine Arbeitsversion für die Nachwelt:

#include <algorithm>
#include <functional>
#include <vector>
#include <boost/random.hpp>

struct bar : std::unary_function<unsigned, unsigned> {
    boost::mt19937 &_state;
    unsigned operator()(unsigned i) {
        boost::uniform_int<> rng(0, i - 1);
        return rng(_state);
    }
    bar(boost::mt19937 &state) : _state(state) {}
};

void foo(std::vector<unsigned> &vec, boost::mt19937 &state)
{
    bar rand(state);
    std::random_shuffle(vec.begin(), vec.end(), rand);
}

Answer 2

In C++03 können Sie keine Schablone instanziieren, die auf einem funktionslokalen Typ basiert. Wenn Sie die Klasse rand aus der Funktion auslagern, sollte es gut funktionieren (Haftungsausschluss: nicht getestet, es könnte andere unheilvolle Fehler geben).

Diese Anforderung wurde in C++0x gelockert, aber ich weiß nicht, ob diese Änderung im C++0x-Modus von GCC bereits implementiert wurde, und es würde mich sehr überraschen, sie in einem anderen Compiler zu finden.

Answer 3

Ich verwende hier tr1 anstelle von boost::random, aber das sollte nicht viel ausmachen.

Das Folgende ist ein bisschen kompliziert, aber es funktioniert.

#include <algorithm>
#include <tr1/random>

std::tr1::mt19937 engine;
std::tr1::uniform_int<> unigen;
std::tr1::variate_generator<std::tr1::mt19937, 
                            std::tr1::uniform_int<> >gen(engine, unigen);
std::random_shuffle(vec.begin(), vec.end(), gen);

Answer 4

Ich dachte, es lohnt sich, darauf hinzuweisen, dass dies jetzt in C++11 ziemlich einfach ist, wenn man nur die Standardbibliothek verwendet:

#include <random>
#include <algorithm>

std::random_device rd;
std::mt19937 randEng(rd());
std::shuffle(vec.begin(), vec.end(), randEng);