Raymond Couture

A search for good multiple recursive random number generators

We report the results of an extensive computer search for good multiple recursive generators, in terms of their lattice structure and implementation speed. Those generators are a little slower than the usual linear congruential generators, but have much longer periods and much better statistical properties. We provide specific parameter sets for 32-bit, 48-bit, and 64-bit computers. We also explain how to build efficient portable implementations and give examples of computer codes in Pascal and C.

An Implementation of the Lattice and Spectral Tests for Multiple Recursive Linear Random Number Generators

We discuss the implementation of theoretical tests to assess the structural properties of simple or combined linear congruential and multiple recursive random number generators. In particular, we describe a package implementing the so-called spectral and lattice tests for such generators. Our programs analyze the lattices generated by vectors of successive or nonsuccessive values produced by the generator, analyze the behavior of generators in high dimensions, and deal with moduli of practically unlimited sizes. We give numerical illustrations. We also explain how to build lattice bases in several different cases, e.g., for vectors of far-apart nonsuccessive values, or for sublattices generated by the set of periodic states or by a subcycle of a generator, and, for all these cases, how to increase the dimension of a (perhaps partially reduced) basis.

On the lattice structure of certain linear congruential sequences related to AWC/SWB generators

We analyze the lattice structure of certain types of linear congru- ential generators (LCGs), which include close approximations to the add-with- carry and subtract-with-borrow (AWC/SWB) random number generators intro- duced by Marsaglia and Zaman, and also to combinations of the latter with ordinary LCGs. It follows from our results that all these generators have an unfavorable lattice structure in large dimensions.

On the lattice structure of the add-with-carry and subtract-with-borrow random number generators

Marsaglia and Zaman recently proposed new classes of random number generators, called add-with-carry(AWC) and subtract-with-borrow(SWB), which are capable of quickly generating very long-period (pseudo)-random number sequences using very little memory. We show that these sequences are essentially equivalent to linear congruential sequences with very large prime moduli. So, the AWC/SWB generators can be viewed as efficient ways of implementing such large linear congruential generators. As a consequence, the theoretical properties of such generators can be studied in the same way as for linear congruential generators, namely, via the spectral and lattice tests. We also show how the equivalence can be exploited to implement efficient jumping-ahead facilities for the AWC and SWB sequences. Our numerical examples illustrate the fact that AWC/SWB generators have extremely bad lattice structure in high dimensions.

Distribution properties of multiply-with-carry random number generators

We study the multiply-with-carry family of generators proposed by Marsaglia as a generalization of previous add-with-carry families. We define for them an infinite state space and focus our attention on the (finite) subset of recurrent states. This subset will, in turn, split into possibly several subgenerators. We discuss the uniformity of the d-dimensional distribution of the output of these subgenerators over their full period. In order to improve this uniformity for higher dimensions, we propose a method for finding good parameters in terms of the spectral test. Our results are stated in a general context and are applied to a related complementary multiply-with-carry family of generators.

On the distribution of

The lattice structure of conventional linear congruential random number generators (LCGs), over integers, is well known. In this paper, we study LCGs in the field of formal Laurent series, with coefficients in the Galois field F2. The state of the generator (a Laurent series) evolves according to a linear recursion and can be mapped to a number between 0 and 1, producing what we call a LS2 sequence. In particular, the sequences produced by simple or combined Tausworthe generators are special cases of LS2 sequences. By analyzing the lattice structure of the LCG, we obtain a precise description of how all the k-dimensional vectors formed by successive values in the LS2 sequence are distributed in the unit hypercube. More specifically, for any partition of the k-dimensional hypercube into 2kl identical subcubes, we can quickly compute a table giving the exact number of subcubes that contain exactly n points, for each integer n. We give numerical examples and discuss the practical implications of our results.

k

We improve on a lattice algorithm of Tezuka for the computation of the k-distribution of a class of random number generators based on finite fields. We show how this is applied to the problem of constructing, for such generators, an output mapping yielding optimal k-distribution.

-dimensional vectors for simple and combined Tausworthe sequences

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

Lattice computations for random numbers

In order to analyze certain types of combinations of multiple recursive linear congruential generators (MRGs), we introduce a generalized spectral test. We show how to apply the test in large dimensions by a recursive procedure based on the fact that such combinations are subgenerators of other MRGs with composite moduli. We illustrate this with the well-known RANMAR generator. We also design an algorithm generalizing the procedure to arbitrary random number generators.

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

We study the multiply-with-carry family of generators proposed by G. Marsaglia (1994) as a generalisation of the previous add-with-carry and subtract-with-borrow families of G. Marsaglia and A. Zaman (1991). We define for them a general (infinite) state space and focus our attention on the (finite) subset of recurrent states. This subset will, in turn, split into possibly several subgenerators. We discuss the uniformity of the d-dimensional distribution of the output of these subgenerators over their full period. In order to improve this uniformity for higher dimensions, we propose a method for finding good parameters in terms of the spectral test.