Guest editors' introduction: special issue on uniform random number generation

A reliable random number generator is obviously a key requirement for any serious stochastic simulation. But what is a “good” generator and how to construct one? These questions will probably never be settled for good. From the point of view of classical information theory (e.g., Shannon’s entropy), no generator can have more randomness in its output than it has in its seed. The basic idea of a random number generator, which is to stretch a short random seed into a long sequence of random numbers, is therefore formally impossible in that setup. The difference between the good and bad generators is simply that the good ones have a better hidden structure. Heuristically, if it is hard to construct a statistical test detecting the presence of a structure by looking only at the output for a “reasonable” time, then the chances that the structure of our next problem and that of the generator will interact badly are deemed “negligible.” This reasoning can be made more formal in an asymptotic sense, in the framework of computational complexity theory. But simulation users want a fast generator of finite size for Monday morning. For this, we are back to heuristics. The game of designing and testing random number generators is somewhat like drugs in sport. On the one hand, new tests are developed to catch a different generator’s defects and, on the other hand, new generators are built which (one hopes) would pass all the statistical tests that can be performed for several years to come. As more powerful computers become available, bigger simulations are performed, so more stringent testing is necessary. Theoretical analyses also often unveil weaknesses in proposed generators. Simulation problems are soon found—or “constructed”—on which the generator breaks its teeth. This special issue makes contributions to these two aspects. In the first article, Matsumoto and Nishimura propose a class of generators based on linear recurrences modulo 2. These generators are very fast, have extremely long periods, and appear quite robust. They provide an implementation in C for a specific instance with period length 2 2 1. This generator produces 32-bit numbers, and every k-dimensional vector of such numbers appears the same number of times as k successive values over the period length, for each k # 623 (except for the zero vector, which appears