Question

我正在从一个随机生成器传递一个streamtring到另一个，以跟踪引擎的当前状态（boost随机库）。它允许我在任何时候停止并保存当前状态，以便稍后在代码中重现一系列或继续它。

它工作正常，直到我使用不同的随机生成器，同时传递相同的字符串流（如下所示）。我不能为这两个使用不同的流，因为在实例中，一个类将以随机顺序调用不同的发行版...

#ifndef RANDOM_HPP
#define RANDOM_HPP
namespace RandomG{

using namespace std;
using namespace boost::random; 


int getSeed()
{
   ifstream rand("/dev/urandom");
   char tmp[sizeof(int)];
   rand.read(tmp,sizeof(int));                                                          
   rand.close();
   int* number = reinterpret_cast<int*>(tmp);                                           
   return (*number);                                                                    
}
void Get_Rstream(stringstream &s)
{               
     mt19937 randgen(getSeed());                                                      
     s.clear();
     s << randgen;                                                                    
}                                                                                        

template<class distribution>                                                             
class Random                                                                             
{                                                                                        
    public:                                                                          
       Random(distribution nd)                                                         
       {       
              mt19937 randgen(getSeed());                                              
              rng=new variate_generator<mt19937,distribution >(randgen, nd);           
       }       
       virtual ~Random()
       {       
              delete rng;                                                              
       }               
       void reset(void)
       {
             (*rng).distribution().reset();                                           
       }       
       double operator()(stringstream &s)                                               
       {                                                                                
             double x;
             s >> (*rng).engine();
             x=(*rng)();
            return x;
       }
    variate_generator<mt19937,distribution > *rng;
};

}
#endif

所以现在如果我实例化这些类的两个实例（低于它的两个统一但它可以是一个统一的和高斯或其他任何东西，并且可以以随机顺序调用）。

#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/normal_distribution.hpp>                                          
#include <boost/random/variate_generator.hpp>
#include "Random.hpp"                                                                    
using namespace boost::random;                                                           
using namespace std;                                                                     



int main()  
{        

            int M=20;
            stringstream ss;
            RandomG::Get_Rstream(ss);
            string ss2=ss.str();
            stringstream ss3;
            ss3.clear();                                                             
            ss3.str(ss.str());

            boost::random::uniform_01<> N;
            RandomG::Random<boost::random::uniform_01<> > *unif_rand1= new    RandomG::Random<boost::random::uniform_01<> >(N);
            boost::random::uniform_01<> U;
            RandomG::Random<boost::random::uniform_01<> > *unif_rand2=new RandomG::Random<boost::random::uniform_01<> >(U);

            (*unif_rand1).reset();
            (*unif_rand2).reset();
            for(int i=0;i<M;i++)
            {       
                    cout << (*unif_rand1)(ss) << " ";
            }
            for(int i=0;i<M;i++)
            {
                    cout << (*unif_rand2)(ss) << " ";
            }
            cout <<"\\\\\\\\\\\\\\\\\\\\"<<"\n";
            (*unif_rand1).reset();
            (*unif_rand2).reset();
            for(int i=0;i<M;i++)
            {
                    cout << (*unif_rand1)(ss3) << " ";
            }
            for(int i=0;i<M;i++)
            {
                    cout << (*unif_rand2)(ss3) << " ";
            }

return 0;
}

这应该给我两个相同的随机数系列，但是我给了unif_rand1相同的随机数，但不是unif_rand2。根据我的理解，将相同的状态提供给两个不同的随机数生成器应该给出相同的结果，还是有一些方法可以在绘制之间重置它们？

结果：

0.525384 0.038626 0.563798 0.705042 0.725001 0.311586 0.843047 0.606338 0.163695 0.437574 \\\\\\\\\\
0.525384 0.038626 0.563798 0.705042 0.725001 0.0566288 0.93966 0.417343 0.686245 0.84118

感谢您的任何回复或建议（代码应该在linux下可重现）。

通过不同的增强随机数发生器传递种子

0 个答案: