RE: [boost] Question about Boost.Random

From: Kris Thielemans (kris.thielemans_at_[hidden])
Date: 2004-07-09 11:47:04

Hi Anders

you probably should read my email on this of a few days ago.
The simple answer is to use
typedef boost::variate_generator<engine_t&, distribution_t> rng_t;
(i.e. with ref)

It all makes sense, it's just hard to get from the doc in my opinion.

Kris

> // The following program illustrates a problem in Boost.Random.
>
> // Is this the desired behavior?
>
> // If so, what is the reason for this?
>
> // I use Boost version 1.31 and GCC version 3.3.3 on Suse 9.1
>
> #include <vector>
> #include <algorithm>
> #include <boost/random.hpp>
>
> // Definition of the random number generator
> typedef boost::mt19937 engine_t;
> typedef boost::uniform_int<int> distribution_t;
> typedef boost::variate_generator<engine_t, distribution_t> rng_t;
>
> int main()
> {
>     const unsigned int N = 13, A = 0, B = 1000;
>     std::vector<int> run1(N), run2(N), run3(N);
>
> // Generate some random integers
>     {
>         engine_t engine;
>         distribution_t distribution(A,B);
>         rng_t rng(engine, distribution);
>         std::generate(run1.begin(), run1.end(), rng);
>     }
>
> // Verify that I get the same sequence if I start again
>     {
>         engine_t engine;
>         distribution_t distribution(A,B);
>         rng_t rng(engine, distribution);
>         std::generate(run2.begin(), run2.end(), rng);
>     }
>
> // It appears that the generator restarts for each generate, since
> // the generate algorithm creates a copy of the functor so that
> // its state is lost
>     {
>         engine_t engine;
>         distribution_t distribution(A,B);
>         rng_t rng(engine, distribution);
>         std::generate(run3.begin(), run3.begin()+N/2, rng);
>         std::generate(run3.begin()+N/2, run3.end(), rng);
>     }
>
> // For me it would seem more natural if the engine class would be a
> // singleton, so that there can be only one object of any particular
> // random generator engine type.
>
> // Our purpose for using random numbers is to simulate physical processes.
> // I can't think of a case when there would be a need for several random
> // engines, even if there can of course be many different random
> // distributions in an application.
>
> // Having the same random number sequence in different parts of a
> simulation
> // can probably create very strange behaviour, since the numbers from the
> // different engines of the same type will be perfectly correlated.
>
> // Perhaps other applications have use of several random engines?
>
>     for(unsigned i=0; i<N; ++i) {
>         if(i==N/2)
>             std::cout<<"Halfway there!"<<std::endl;
>         std::cout
>             <<run1[i]
>             <<" == "<<run2[i]
>             <<" == "<<run3[i]
>             <<std::endl;
>     }
>
>     return 0;
> }
>
> // Anders Edin
> // Sidec Technologies AB
>
>