using <random> properly

[jiggunjer]

I'm trying to switch to <random> instead of using the older rand(). After googling some examples I came up with function to generate an array of random ints between 1 and 10, but there's 2 problems.

- When I generate an array of size 20, some elements always have the same value with repeated experiments.

- The values far exceed 10 (by more than a million sometimes), and I also get zeros, but so far no negatives observed.

without further ado:

template<size_t N>
  std::array<int,N> random_data(){
      std::array<int,N> arr; // I get only zeros when I brace initialize this
      //std::random_device rd;
      //std::mt19937 rg(rd());
      std::default_random_engine rg;
      std::uniform_int_distribution<> dist(1, 10);
      for (int x : arr ){x = dist(rg);}
      return arr;
  }

//the code in main:
auto mydata = random_data<20>();
  for (auto x : mydata) cout<<x<<"\n";

Anyone see what I'm doing wrong?

[whiteflags]

Well one of the major problems is that you may not be filling the array. This appears to be correct.

for (int &x : arr){ x = dist(rg); }

You should use something other than random_device unless you are on a system that implements randomness. For instance, on cppreference, the following is given:

 std::random_device rd2("/dev/random"); // much slower on Linux
    for(int n = 0; n < 10; ++n)
        std::cout << d(rd2) << ' ';
    std::cout << '\n';

[jiggunjer]

ah of course the reference. thanks! I need to use that range for loop more often...

How do I know if my system implements randomness, and how big is the problem on systems that don't?

[whiteflags]

Well, the problem is the default engine can be anything. If you are on a system that implements randomness, you ought to know. See Hardware random number generator and the see also section.

One of the things I also think you are forgetting is that you still need to seed your engine, and all the problems that come with doing that are still there.

[Guest]

How do I know if my system implements randomness, and how big is the problem on systems that don't?

std::default_random_engine should define some random engine you can use, so this is not a problem. std::random_device is the shady one.

As whiteflags said, you will need to seed your engine with changing values if you want changing sets of random numbers to be generated. You could for instance use the value returned by std::time, which changes at 1 second intervals, for that:

#include <ctime>

rg.seed(std::time(nullptr));

[Elysia]

std::default_random_engine should define some random engine you can use, so this is not a problem. std::random_device is the shady one.

I don't find random_device shady at all. Why would it be shady?

As whiteflags said, you will need to seed your engine with changing values if you want changing sets of random numbers to be generated. You could for instance use the value returned by std::time, which changes at 1 second intervals, for that:

Much better is to actually initialize with a truly random seed, like one generated from std::random_device:

std::random_device rd;
std::mt19937 engine{ rd() };
std::uniform_int_distribution<int> dist(1, 10);
for (auto & x : myarray)
    x = dist(engine);

Of course, some stupid compilers fail to implement random_device correctly (I'm looking at YOU gcc!). In that case, you'll just have to fallback on std::time. Still, if you can avoid stupid compilers, random_device is MUCH better.

[jiggunjer]

Does that include g++ 5.1?

[Elysia]

If you mean improperly implementing std::random_device, then yes.

[Guest]

If you mean improperly implementing std::random_device, then yes.

That I meant. I recall having problems with it on Windows/MinGW when trying out <random> and then wondered why it was there in the first place.

[algorism]

If you mean improperly implementing std::random_device, then yes.

In what way is it improperly implemented?

[Elysia]

After some checking, apparently it's not improperly implemented, it's just stupidly implemented since it returns the exact same sequence every time it's run.

[algorism]

After some checking, apparently it's not improperly implemented, it's just stupidly implemented since it returns the exact same sequence every time it's run.

That sounds broken to me as it certainly isn't what one would expect. Apparently it's implemented with a pseudo-random number engine with a default seed, which I assume your checking determined was allowed. But it really shouldn't be allowed to use a fixed seed. I wonder if there's gcc compile-time options (I mean when building gcc itself) that turn on/off using an actual random device or not.

I assume your testing it under mingw (or cygwin) so it may not be a general property of gcc.

[Elysia]

That sounds broken to me as it certainly isn't what one would expect. Apparently it's implemented with a pseudo-random number engine with a default seed, which I assume your checking determined was allowed. But it really shouldn't be allowed to use a fixed seed. I wonder if there's gcc compile-time options (I mean when building gcc itself) that turn on/off using an actual random device or not.

Yeah, the standard allows it when there's no appropriate hardware available to generate true random numbers. That's why it's a stupid implementation since there are APIs in Windows that can give truly random numbers, and VC++ implements that, so why GCC doesn't is beyond me.

I assume your testing it under mingw (or cygwin) so it may not be a general property of gcc.

Yeah, it's mingw. As far as I know, this is only a problem under Windows.

[whiteflags]

Yeah, the standard allows it when there's no appropriate hardware available to generate true random numbers. That's why it's a stupid implementation since there are APIs in Windows that can give truly random numbers, and VC++ implements that, so why GCC doesn't is beyond me.


Yeah, it's mingw. As far as I know, this is only a problem under Windows.

Well, now you know why I said you shouldn't use random_device. It works okay if you actually have hardware, or you can access something like /dev/random

[Elysia]

It works okay if you actually have hardware...

But that's the thing - every PC has "the hardware". It's just some stupid compiler that refuses to implement it properly.
Regardless, yeah, don't use it if you need to use gcc.