Utilisation de boost :: random comme RNG pour std :: random_shuffle

Question

J'ai un programme qui utilise le générateur de nombres aléatoires mt19937 de boost :: random. J'ai besoin de faire un random_shuffle et je veux que les nombres aléatoires générés pour cela proviennent de cet état partagé afin qu'ils puissent être déterministes par rapport aux nombres générés précédemment par mersenne twister.

J'ai essayé quelque chose comme ceci:

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

mais je reçois une erreur de modèle appelant random_shuffle avec rand. Cependant cela fonctionne:

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

Probablement parce que c'est un appel de fonction réel. Mais évidemment, cela ne garde pas l'état de la twister mersenne originale. Ce qui donne? Y at-il un moyen de faire ce que j'essaye de faire sans variables globales?

Answer 1

En C++ 03, vous ne pouvez pas instancier un modèle basé sur un type fonction-local. Si vous déplacez la classe rand hors de la fonction, cela devrait fonctionner correctement (avertissement: non testé, il pourrait y avoir d'autres bugs sinistres).

Cette exigence a été assouplie en C++ 0x, mais je ne sais pas si la modification a été implémentée dans le mode C++ 0x de GCC, et je serais très surpris de la trouver dans tout autre compilateur .

Answer 2

Dans les commentaires, Robert Gould a demandé une version de travail pour la postérité:

#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 3

J'utilise TR1 au lieu de boost :: ici au hasard, mais ne devrait pas beaucoup d'importance.

Ce qui suit est un peu compliqué, mais cela fonctionne.

#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

Je pensais qu'il était intéressant de souligner que c'est maintenant assez simple en C++ 11 en utilisant uniquement la bibliothèque standard:

#include <random> 
#include <algorithm> 

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