## Pseudo random number generators 2

After the little bit of analysing PRNGs in the last blog post, which PRNGs exactly seem good?

##### Fastest PRNGs

If one either needs a very fast PRNG or one has some means to easily test that the output is good enough (like looking to see if a noise filter produces no vissible aritifacts) then folllowing could be considered.

**Linear congruential generators, Additative lagged fibbonacci generators or even just an array of random numbers that gets used repeatedly, … **

Each of these has its serious flaws, LCGs have very poorly performing LSBs, that is the lowest n bits never have a period larger than 2^{n}. ALFGs contain number triplets (the ones spaced like the taps used in the PRNG) that when used as coordinates in a cube would all fall in a single plane. Still these generators are often good enough, and have been used for a long time and are widespread, that is all C libs ive seen use either of them for rand() for examle.

##### Good and fast PRNGs

If one wants a generator free of big flaws and that is still reasonably fast then the number of choices goes down, first there is

**4 tap additative LFG** (x_{i} = x_{i-55} + x_{i-119} + x_{i-179} + x_{i-256} mod 2^{n}) this one passed all of testu01 but has a obvious linear dependancy between its values.

**Combined generators**, these generators combine the output of several simple generators and generally pass all tests, many of them though are slow like CLCG4 which combines 4 LCGs, combined generators like f_{i} = g_{i} + h_{i} also have the flaw that f_{i} – f_{i+p} = h_{i} – h_{i+p} when p is the period of g. This also means that f_{i} – f_{i+p} – (f_{i+q} – f_{i+p+q}) = 0 when p and q are the periods of h and g. Thus all combined generators which are made of constituent generators with “bruteforceable periods” are cryptographically likely very weak. A combined generator that is reasonable fast is KISS99.

**Multiplicative lagged fibonacci generators**, like for example (x_{i} = x_{i-55} * x_{i-24} mod 2^{n}) these generators also tend to pass all tests as long as only the most significant bits are used, that is for example the top 32 bit of a 64 bit generator. The least significant bit of such a generator is always 1, its next bit behaves like a LFSR identically to the least significant of an additative or xor based LFG. One trick to get rid of the least significant bit without ending up with just 31 or 63 bits is to use 2*a*b+a+b instead of a*b, this works because a and b are (have to be) odd in a normal MLFG and (2*A+1)(2*B+1) = 4AB + 2A + 2B + 1

##### Best but slow PRNGs

“Anything” based on AES, SHA-1, MD5, …

##### Bad PRNGs

These are PRNGs that are both slower and worse in terms of their output than others, examples are

**Mersene twister**, becuase its output is purely based on the XOR of previous bits thus being not nearly as good as some pretend it to be while it also isnt nearly as fast compared to other properly implemented PRNGs.

**Combined generators with lots of modulo by non power of 2**, these are slow …

**Weak generators from which many output values are thrown away**, again these are slow …