VERY ROUGH WORK IN PROGRESS..NO REAL USEFUL INFORMATION AS OF YET.
Overview
The purpose of this page is to give an rough overview of how pseudo random number generators (PRNG) work and a rough idea of how to choose ones which are adequate for a game runtime.
Rules of thumb
- Never use the same instance of a generator in more than one thread.
- Never create static utility methods which call a generator unless single threaded (same as previous).
- XXX
XXX Use different generators if you need a more expensive one for a sub-set of tasks...oh, and don't really worry about any of this stuff if you just don't generate many random numbers.
Everything below this point can (and should) be ignored unless you are generating a large numbers of random numbers per frame OR you tempted to use OR are using a "good" random number generator especially one with a period greater than 2
64. Again this page is only dealing with PRNGs for game runtimes where "real" money is not directly involved.
Introduction
The vast majority of PRNGs all work in the same way. They take some state-data in the form of a sequence of bits and perform computations which mix the bits. Notice that hashing and random number generation are very similar. A given generator will have a
period which is the number of unique values the state will assume before wrapping around and repeating itself. Yeah, that was clear. OK, let's pretend like we're using a 2-bit integer for our state data, so our 2-bit integer can have values of:
{0,1,2,3}. For our random number generator we want to produce some permutation (
MathWorld,
Wikipedia) of that set which appears random. The number of permutations of a set with
n elements is
Factorial[n], so we have 24 choices for our 2-bit integer. Limiting the set to those that start with '0' (all the remaining are rotations), we have:
{0,1,2,3},{0,1,3,2},{0,2,1,3},{0,2,3,1},{0,3,1,2},{0,3,2,1}.
Now obviously none of the above permutation choices look very random but this is exactly how random number generators work. The problem here is that there just aren't enough unique values that any of the permutations appear random. Luckily factorials explode and if we were talking about only 8-bits then there would be approximately 8.6x10
506 choices and 16-bits is ~5.2x10
287193. Other than some very narrow special cases (like in GLSL, when attempting to avoid using integers) there's no reason to use generators with less than 32-bits.
An implication of this is that the period can be at most 2
n, where 'n' is the number of bits. On this page we will only consider "full period generators" which will have a period of either 2
n or 2
n-1. The minus one comes into play for generators for which zero is an invalid state.
This does not imply that PRNGs with longer periods are superior in quality than those that are shorter.
Period
As mentioned above the period of a PRNG is the length of the sequence that it generates. Once the period is exhausted, the sequence wraps-around and starts to repeat itself.
For scientific usage long periods are important. The reason for this is that statistically they will begin show defects if in "single computation" more than
sqrt(T) random numbers are used, where
T is the period. Note that the
sqrt(T) = T1/2. Even more important is because one can break a problem across multiple CPUs/servers/whatever to attack a single problem and the longer the period, the lower the probability that the individual computation units will be using overlapping parts of the sequence.
Note the "single computation" part.
There's the mistaken notion in games that one needs a period long enough that it never repeats during gameplay. Not at all, it simply should be long enough that every single computation has more than enough values to complete.
So what about the period? Do we need to think in terms of T or sqrt(T)? The question is more or less moot. As noted above there's no reason to use a generator with a period shorter than ~2
32, so you should feel safe if any single problem needs no more than 2
16 or 65536 random numbers, which seems highly unlikely. At the opposite end of the spectrum (SEE: url=http://www.java-gaming.org/topics/orders-of-magnitude/27917/view.html]orders of magnitude[/url]) it would take the Cray Titan more than 17 minutes to generate 2
64 random numbers and an infinite amount of time to generate 2
128. Sticking the
sqrt(T) rule of thumb this means you never need a generator with a period greater than 2
128.
Dimensions
Humm...any ideas here kids, other than don't worry about dimensions. Just don't use a LCG for more than 2.
Quality
PRNGs do not attempt to create sequences which appear random. Instead they are attempting to simulate
statistical randomness.
For our purposes the main usefulness of having a generator which passes the majority to all of XXXX
XX note uniform distribution
XX Write something somehow convincing about how quality a la. diehard and various crushes shouldn't matter.
Old Skool
Permutation PolynomialsSEE:
GLSL TricksWeyl Generators--STUB AGAIN -- stuck in place since I mentioned them in the GLSL tricks page
This family is based on the
equidistribution theorem (properties of irrational numbers). Quality varies widely depending on formulation and precision. Like permutation polynomials they can be computed purely in floating point and are currently useful on the GPU.
The simplest version looks like:
un = na mod 1 = (un-1+a) mod 1where:
'a' is a fixed irrational number mod 1.
'n' is the number in the sequence (0,1,2...)
Common variants include nested:
un = n(na mod 1) mod 1and shuffled nested (where 'm' is a fixed large integer):
vn = m(n(na mod 1) mod 1)+1/2 un = (vn(vn a mod 1)) mod 11
2
3
4
5
6
7
8
| vec3 weyli(vec3 s, vec3 a) { return fract(s+a); } vec3 weyl(vec3 n, vec3 a) { return fract(n*a); } vec3 weyln(vec3 n, vec3 a) { return fract(n*fract(n*a)); } vec3 weylns(vec3 n, vec3 a) {
n = m*fract(n*fract(n*a))+0.5;
return fract(n*fract(n*a));
} |
XXXX
Linear Congruent GeneratorsLinear congruent generatorsMention some mod-power-of-two LCGs here. Non-power-of-two just ain't worthwhile. Nor are IHMO sub-cycle generators.
New kids on the block
Mention some cheap LSFRs here
Summary
ReferenceBlah, blah
This wiki entry has had 4 revisions with contributions from 1 members.
(
more info)
