TestU01：C语言随机数生成器实证测试软件库

25 浏览量更新于2024-07-14 收藏 780KB PDF 举报

"TestU01 是一个用 ANSI C 语言实现的软件库，用于对随机数生成器进行实证统计测试。该库由 Pierre L’Ecuyer 和 Richard Simard 在蒙特利尔大学的计算机科学与运筹学部门开发。TestU01 提供了一系列工具，用于对均匀随机数生成器（RNG）进行统计测试，包含了多种通用和特定的随机数生成器，并实现了多种经典及新颖的统计测试方法。此外，它还提供了一些用于生成器预定义和用户自定义的特定测试套件，以及用于绘制生成器产生的点向量的基本绘图工具。" TestU01 软件库的核心功能和知识点包括： 1. **随机数生成器的实证测试**：TestU01 的主要目的是通过统计测试评估随机数生成器的质量，确保它们产生的数字序列具有足够的随机性和不可预测性。 2. **ANSI C 实现**：TestU01 采用 ANSI C 编程语言编写，这使得它在各种操作系统和硬件平台上具有较好的可移植性。 3. **通用和特定随机数生成器**：库中包含了多种类型的通用生成器，这些生成器可以以泛型形式使用，同时也支持文献中提出的或广泛使用的特定生成器。 4. **统计测试**：TestU01 实现了经典的统计测试，如线性复杂度测试、秩测试、复共轭测试等，并增加了文献中提到的一些其他测试和一些原创测试。 5. **用户自定义生成器**：除了预定义的生成器，TestU01 还允许用户自定义随机数生成器，并对其进行测试，增强了软件的灵活性和适用范围。 6. **测试套件**：特定的测试套件针对的是在[0,1]区间内的均匀随机数序列或特定的序列。这有助于针对不同应用领域进行定制化的测试。 7. **绘图工具**：TestU01 提供了基本的绘图工具，能够帮助分析生成器产生的点集，以视觉方式检查其随机性。 8. **文献支持**：TestU01 的设计和实现参考了众多文献，确保了其在统计测试领域的理论基础扎实。这个软件库对于随机数生成器的开发者和应用者，特别是在数值模拟、加密算法、统计建模等领域工作的研究人员来说，是一个极其宝贵的资源，因为它提供了全面且严谨的测试手段，有助于确保所使用的随机数生成器的高质量。

void unif01_WrLongStateDef (void);

Dummy function used when the state of the current generator is a large array and we do not want

to write the full state. Writes the message “Not shown here ... takes too much space”.

unif01_Gen * unif01_CreateDummyGen (void);

Creates a dummy generator, which does nothing and always returns zero. It can be used for

instance to measure the overhead of function calls when comparing generator’s speeds (see the

timing tools below).

void unif01_DeleteDummyGen (unif01_Gen *gen);

Frees the dynamic memory used by the dummy generator above.

Output ﬁlters

The following describes some ﬁlters that can be added to transform the output of a given

generator. In each case, a new generator object is created that will eﬀectively apply the ﬁlter

to the original generator. One may apply more than one ﬁlter at a time on a given generator

(for example, one may apply the Double, the Bias, the Trunc and the Lac ﬁlters on top of

one another). It suﬃces to create the appropriate ﬁlters as described below. The resulting

ﬁltered generator(s) will call the original generator behind the scenes. Thus the state of the

original generator will evolve as usual, even though it is not called directly.

The diﬀerent ﬁlters applied on an original generator are not independent but are related

as the elements of a stack. When they are no longer in use, they must be deleted in the

reverse order of their creation, the original generator being the last one of this group to be

deleted. Figure 2.8 illustrates how these facilities can be used.

unif01_Gen * unif01_CreateDoubleGen (unif01_Gen *gen, int s);

Given a generator gen, this function creates and returns a generator with increased precision,

such that every call to this new generator corresponds to two successive calls to the original

generator. The method GetU01 of this doubled generator returns (U

+ U

) mod 1, where

and U

are the results of two successive calls to the method GetU01 of gen. If the current

generator has 31 bits of precision, for example, then one can obtain 53 bits of precision from

GetU01 by creating this new generator with s between 22 and 31.

unif01_Gen * unif01_CreateDoubleGen2 (unif01_Gen *gen, double h);

A more general version of unif01_CreateDoubleGen where the method GetU01 of the double

generator returns (U

+ hU

) mod 1. Restriction: 0 < h < 1.

unif01_Gen * unif01_CreateLacGen (unif01_Gen *gen, int k, long I[]);

Given an original generator gen, this function creates and returns a generator involving lacunary

indices, such that successive calls to this new generator will no longer provide successive values

from the original generator, but rather selected values as speciﬁed by the table I[0..k-1], in

a circular fashion. More speciﬁcally, if u

, u

, . . . is the sequence produced by the original

gen, if the table I[0..k-1] contains the non-negative integers i

, . . . i

k−1

(in increasing order),

and if we put L = i

k−1

+ 1, then the output sequence of the new generator will be:

, u

, . . . , u

k−1

, u

L+i

, u

L+i

, . . . , u

L+i

k−1

, u

2L+i

, u

2L+i

, . . . .

For example, if k = 3 and I = {0, 3, 5}, the output sequence will be the numbers

, u

, . . .

of the original generator. To obtain every s-th number produced by the original generator for

example (a decimated sequence), one should take k = 1 and I = {s −1}.

unif01_Gen * unif01_CreateLuxGen (unif01_Gen *gen, int k, int L);

Given an original generator gen, this function creates and returns a new generator giving the

output of the original generator with luxury level L: out of every group of L random numbers,

the ﬁrst k are kept and the next L −k are skipped.

unif01_Gen * unif01_CreateBiasGen (unif01_Gen *gen, double a, double p);

Given an original generator gen, this function creates and returns a new generator giving a biased

output of the original generator. The output is biased in such a way that the density becomes

constant with total probability p over the interval [0, a), and constant with total probability

1 − p over [a, 1) (the two constant densities are diﬀerent). For example, by choosing p = 1 and

a = 0.5, all the random numbers generated by GetU01 will fall on the interval [0, 0.5). This

ﬁlter can be used, for example, to study the power of certain statistical tests. Restrictions:

0 < a < 1 and 0 ≤ p ≤ 1.

unif01_Gen * unif01_CreateTruncGen (unif01_Gen *gen, int s);

Given an original generator gen, this function creates and returns a new generator giving the

output of the original generator truncated to its s most signiﬁcant bits. Restriction: s ≤ 32.

unif01_Gen * unif01_CreateBitBlockGen (unif01_Gen *gen, int r, int s,

int w);

Consider a group of v ≤ 32 successive 32-bit integers outputted by generator gen. For each of

these, drop the r most signiﬁcant bits and keep the s following bits numbered b

, b

, . . . , b

starting with the most signiﬁcant, for 1 ≤ i ≤ v. Make with all these a v × s matrix of bits,

say B. The generator returned by this function is a ﬁlter that builds new 32-bit integers from

v × w submatrices of B. The number of columns of the submatrix w must be a power of 2 no

larger than 32 and it must be ≤ s. If w does not divide s exactly, the last submatrix of B will

have less than w columns and will be disregarded.

If the stream of bits thus obtained from gen is

, b

, . . . , b

, b

, . . . , b

, b

, . . . , b

, . . .

then the new integers returned by the ﬁlter will be 32-bit integers taken from the rearranged

stream of bits so that the ﬁrst new number is (its most signiﬁcant bit being given ﬁrst)

, b

, . . . , b

, b

, . . . , b

, b

, . . . , b

the second new number is made of the bits (its most signiﬁcant bit ﬁrst)

1(w+1)

, b

1(w+2)

, . . . , b

1(2w)

, b

2(w+1)

, b

2(w+2)

, . . . , b

2(2w)

, . . . , b

v(w+1)

, b

v(w+2)

, . . . , b

v(2w)

and so on.

The following examples illustrates how the ﬁlter works. If r = 0 and w = s = 32, then the

ﬁlter has no eﬀect, the new integers being the same as those outputted by gen. If r = 0 and

w = s = 1, then the ﬁlter will return integers made only from the most signiﬁcant bit of the

original integers, all other bits being dropped. If r = 0, w = 1 and s = 32, then the ﬁlter

will return integers made from the columns of B, i.e., since the rows of B are made of the

original integers, the ﬁlter will return the columns of B as the new integers. Restrictions: r ≥ 0,

0 < s ≤ 32 and w in {1, 2, 4, 8, 16, 32}.

void unif01_DeleteDoubleGen (unif01_Gen *gen);

void unif01_DeleteLacGen (unif01_Gen *gen);

void unif01_DeleteLuxGen (unif01_Gen *gen);

void unif01_DeleteBiasGen (unif01_Gen *gen);

void unif01_DeleteTruncGen (unif01_Gen *gen);

void unif01_DeleteBitBlockGen (unif01_Gen *gen);

Frees the memory used by the generator created by the corresponding Create functions above.

Combining generators

These functions permit one to deﬁne the combination of two, three or more generators.

The resulting generator calls the component generators behind the scenes, so it changes their

state. The component generators must not be destroyed as long as the combination generator

is in use. One can obtain the combinations of more than three generators by combining the

generators obtained from combinations of two or three generators.

unif01_Gen * unif01_CreateCombAdd2 (unif01_Gen *gen1, unif01_Gen *gen2,

char *name);

This function creates and returns a generator whose output is the addition of the outputs

modulo 1 of the method GetU01 of the two generators gen1 and gen2. The character string

name may be printed in reports to identify this new combined generator.

unif01_Gen * unif01_CreateCombAdd3 (unif01_Gen *gen1, unif01_Gen *gen2,

unif01_Gen *gen3, char *name);

Same as unif01_CreateCombAdd2, except that the returned generator is the combination (the

addition of the outputs modulo 1 of the method GetU01) of the three generators gen1, gen2

and gen3.

unif01_Gen * unif01_CreateCombXor2 (unif01_Gen *gen1, unif01_Gen *gen2,

char *name);

This function creates and returns a generator whose output is the bitwise exclusive-or (XOR)

of the outputs of the two generators gen1 and gen2. The character string name may be printed

in reports to identify this combined generator.

unif01_Gen * unif01_CreateCombXor3 (unif01_Gen *gen1, unif01_Gen *gen2,

unif01_Gen *gen3, char *name);

Same as unif01_CreateCombXor2, except that the returned generator is the combination of the

three generators gen1, gen2 and gen3.

void unif01_DeleteCombGen (unif01_Gen *gen);

Frees the memory used by one of the combination generators returned by the Create functions

above, but does not delete any of its component generators.

Parallel generators

The following functions allow the joining of the output of several generators or of diﬀerent

substreams of the same generator into a single stream of random numbers. This can be

used to test for apparent correlations between the output of several generators or several

substreams used in parallel. For example, one may want to choose seeds that are far separated

for the same generator, while making sure that such seed choice is statistically valid and does

not introduce unwanted correlation between the substreams thus deﬁned.

unif01_Gen * unif01_CreateParallelGen (int k, unif01_Gen *gen[], int L);

Creates and returns a generator whose output is obtained in a round-robin way L numbers at

a time from each of the k generators gen[i] as follows: the ﬁrst L numbers are generated from

gen[0], the next L numbers are generated from gen[1], and so on until L numbers have been

generated from gen[k-1], after which, this whole process is repeated. It is important that none

of the generators gen[i] be destroyed as long as the parallel generator is in use.

void unif01_DeleteParallelGen (unif01_Gen *gen);

Frees the memory allocated by the parallel generator returned by the Create function above,

but does not delete any of its component generators, which is the responsibility of the program

that created them.

External generators

Although TestU01 implements many generators both in generic and in speciﬁc forms, it is

not possible to implement all those that are in existence because there are just too many and

new ones are proposed regularly. The typical user would like to test his preferred generator

with as little complications as possible. The functions below allows one to do just that. As

long as the generator is programmed in C, one has but to pass the function implementing

the generator to one of the functions below and call some of the tests available in TestU01.

It is the responsibility of the user to ensure that his generator does not violate the conditions

described in the functions below. For the call in unif01_CreateExternGen01, his generator

must return ﬂoating-point numbers in [0, 1). For the calls in unif01_CreateExternGenBitsL

and unif01_CreateExternGenBits, his generator must return an integer in the interval

[0, 2

− 1]. If these conditions are violated, the results of the tests in TestU01 are unpre-

dictable.

unif01_Gen *unif01_CreateExternGen01 (char *name, double (*gen01)(void));

Implements a pre-existing external generator gen01 that is not part of TestU01. It must be a

C function taking no argument and returning a double in the interval [0, 1). Parameter name

is the name of the generator. No more than one generator of this type can be in use at a time.

unif01_Gen *unif01_CreateExternGenBits (char *name,

unsigned int (*genB)(void));

Implements a pre-existing external generator genB that is not part of TestU01. It must be a C

function taking no argument and returning an integer in the interval [0, 2

−1]. If the generator

delivers less than 32 bits of resolution, then these bits must be left shifted so that the most

signiﬁcant bit is bit 31 (counting from 0). Parameter name is the name of the generator. No

more than one generator of this type can be in use at a time.

unif01_Gen *unif01_CreateExternGenBitsL (char *name,

unsigned long (*genB)(void));

Similar to unif01_CreateExternGenBits, but with unsigned long instead of unsigned int.

The generator genB must also return an integer in the interval [0, 2

− 1].

void unif01_DeleteExternGen01 (unif01_Gen * gen);

void unif01_DeleteExternGenBits (unif01_Gen * gen);

void unif01_DeleteExternGenBitsL (unif01_Gen * gen);

Frees the memory used by the generator created by the corresponding Create functions above.

As an example, Figure 2.2 shows how to apply SmallCrush, a small predeﬁned battery

of tests (described on page 143) to the generators MRG32k3a and xorshift, whose code is

shown in Figures 2.3 and 2.4. One must compile and link the two external ﬁles with the

main program and the TestU01 library. The generator MRG32k3a returns numbers in (0, 1)

剩余218页未读，继续阅读

weixin_38696590

粉丝: 6
资源: 927

TestU01：C语言随机数生成器实证测试软件库

TestU01测试官方guide

NIST+TestU01相关.zip

包含NIST、TestU01随机数测试包

TestU01-1.2.3_changekcj_worepem_testu01_

pseudo-random-number-generators:伪随机数生成器在 C 语言中的实现和使用 TestU01 的评估 :game_die:

Python库 | testu-0.0.7.2.tar.gz

TESTU01测试包下载

testU3DSerialPort.rar

Unconventional Type of PRNG in GO:在 Go 中实现一种更新类型的 PRNG-开源

Obrotomierz：Projekt do testu mojego czujnika indukcyjnego。 Zrobiłemładnyobrotomierz z ekranem LCD液晶显示屏WHz i RPM，一个杂乱的czasktóryupływamiędzyposzczególnymizałączeniamiczujnika

最新资源