Does the range of the random number generator effect the volitility of the game?

Why is there a need for a slot machine to pick large random numbers in the billions of number vs just a smaller number? Do slot manufacturers use larger numbers to make the games less volitle?

Thanks in Advance!

Jim

The maximum size of the original random number doesn't make any noticeable difference. It will get mapped to a smaller one, perhaps using the mod() function. For example, if RN is the original integer, and they needed one from 0 to 37, to simulate a roulette game, they might do x=RN%38.

So why do Rng's pick such large numbers?

Mostly it's an artifact of the computation. RNG output is often stored in a primitive type, meaning you'll end up with either 32 or 64 bits of output. If that's represented as an integer, the range is quite large. However, the range of a PRNG isn't nearly as important as the period.

It is my understanding that most RNGs select a decimal fraction, many decimal places long:
0 <= x < 1 (or maybe it's 0 < x <= 1)

It then multiplies to get a number in the range you're looking for. Depending on the program, it may provide a whole number.


The fact that the RNG in slot machines produces exceedingly large numbers may, or may not even be a fact. If it's a true fact, I'd ask, why? Does it really make is any more random?

I truly believe that it just selects a number from 1 to 256, or 384, or however many stops there are on the virtual wheel - but that's it.

I'm trying to find out to find out if the range of the Rng effects the volatility of the game? In other words why is there a need to pick a number between 0 -4 billion and then map that to a virtual reel? Couldn't you just as easily picked a number between 1 and the number of virtual reel stops? What purpose does the large number serve?

Yeah, I agree with you, but suddenly thought of a plausable reason.

The assumption is that a RNG will have an even distribution of picking the numbers in the range.

But what if, despite the best efforts to design it properly, that the distribution wasn't even? What if there was an extremely slight bias, that some how is not multiplied when the range expands?

I.E. If there is a slight bias for one number, expanding the range reduces the impact of that bias.


Let's say the number 87 gets selected 1% more often than any other number.

If the RNG for a slot with 256 stops per reel picks a number from 1 to 256, then that bias *hardly* noticable, and, depending on what that number is mapped to might be a good or bad thing. Note: Hardly noticable, but still there.

But if the RNG picked a number from 1 to 256,000,000, then divide by 1,000,000, the 1% bias towards number 87 has a 0.000001% impact - which is a lot closer to zero.

Here is my guess: Since the RNG is actually a "pseudo" random number generator, having bilions of combinations makes it very difficult to know when they have been exhausted (if that ever occurs), and the sequence starts again.

Depends how the pRNG is actually implemented. You can use a pRNG along with a noise generator to get a RNG.

The system can't "just" pick a number between 1 and 384. That's not how computers work. Underneath it will generate a byte (or multi-byte) long string of 1 and 0's which are then converted in to a simple integer. Hopefully with out any bias. If there's 2^32 possible strings, you'll notice 384 doesn't divide directly into it. This means if you used a straight modulo function some numbers in that 384 range would be mapped -slightly- more often to strrings than others.

So what I think you'd do is map it to 512, and then reject any number greater than 384.

The byte long string is generated by some clever math which operates on the string of bits, to create a new string of bits. If you repeated this operation a number of times based on some external noise, you'll have a series of random numbers which are good enough for the one armed bandits, as the strings are mapped to numbers, and the numbers mapped to slots on the reels, and the underlying number used is obscured from the player.

Without giving too many details I wrote a RNG for an organization. The architecture of the computer means you will always return a series of 0s and 1s, usually a power of 2. As described, this can map to a number 0 to 1. The importance of having a large number of significant digits is that say you wanted 1 to 384, you would get a more accurate even distribution (say) 1 to 11184810 = 1, etc. (You don't ignore numbers as you could get into a loop waiting for a valid number.)

Also one important feature is how long it takes (unless there's external intervention such as noise) before the output stream is repeated. In theory the internal state of the RNG will be a series of words, double words etc. that has to at least exceed this number.

Suppose, using a calculator, you kept a 12 digit number and output the middle four digits. To create the next number (say) multiply by A and add B (or something similar ignoring overflow). Assuming A and B were good, your stream would repeat every 10^12 - for instance 000000000000 would be followed by B and have to wait until every other permutation had occurred before returning.