Read Me file for RandIntG.exe, v. 2.01 (2000-10-16).

Win32:  Windows 95 or Windows NT 4.0.

This program generates lists of nonnegative, 32-bit
random numbers.  It outputs each list in decimal
and hex integers.  Each random byte corresponding
to a printable ASCII character also is output in a
string below the numbers, for possible use in
password composition.   On exit from the program,
a capture window presents all results for optional
save to a text file.

Install RandIntG by unZIPing the release file to any
convenient directory.

You should see:
   ReadMe.txt    . . .     8500 bytes
   RandIntG.exe  . . .  188,416 bytes
   
Drop the .exe into any folder to create an icon.

Version 2.01 makes minor improvements internally
in the randomization.

-----------------------------------------------------
Program Details:

Press [Generate] for a list of 16 new random numbers.

Repeat any number of times.   The numbers are true
random numbers, not pseudorandom; so, the lists must
be saved for repeatability.

Press [Copy] to copy the latest (one) list to the
Windows clipboard.  Repeat [Generate] and [Copy] any
number of times:  The separate lists will remain
visible unless closed individually; they all will
close after [Quit] and then [Exit] from the capture
window.

Press [Quit] to cease random number generation.  
You will be presented a capture window which has 
cumulated all lists during the session, whether 
previously [Copy]'ed or not.   Exitting from this
capture window will terminate RantIntG.

In the capture window (which will not display newline
characters properly--to minimize peeking), you may 
select and copy parts of the cumulated lists to the 
clipboard, or you may save all cumulated lists to a 
text file.   Any text editor will display the 
captured, saved lists formatted neatly.

-----------------------------------------------------
Internal Details:

This is a C++ program developed in the Borland 5.01
Integrated Development Environment.   Source is not
provided.

The program source was about 1000 lines, residing
in a header file for declarations, and in two
implementation files.  Side files for Windows 
resources also were used.

When [Generate] is pressed, the displayed seed, or
the default seed of 0, is combined with the current
millisecond-resolved system real-time clock value to
reseed each number listed; so, the results are truly
random, not pseudorandom.  An initial user seed
optionally may be entered, but this rarely will be 
found useful and in any case will have little 
residual effect after one [Generate].

Each 32-bit integer is formed by concatenating two 
raw, 16-bit system rand() ints, which always have
a MS bit of 0, and then XORing two new random bits
at positions 31 and 15 to make a fully random 
integer.

The string of printable characters is composed by 
testing in order each byte in the random number
list against the ANSI 'C' isgraph() filter.

-----------------------------------------------------
Statistics:

CAUTION:  The sampling distribution of the random
numbers may be platform specific.  Only Windows NT
4 was used in the sampling below.   One would
expect that, the busier the multitasking system, the
better the randomization.

As a coarse check, 100 lists were generated in two
separate, continuous series:  The first series of 50
lists was generated at a rate of one per 3 seconds,
as regularly as possible manually.   After a few
minutes' delay, a second series of 50 lists was 
generated at a regular rate of one per 30 seconds.
Timing of each [Generate] was within about 0.5 sec.
The captured text lists were saved to disc for
analysis.

The sampling runs were done in relatively quiet 
Windows NT 4.0 (Service Pack 3), on a 200 MHz Dell
Pentium Pro PC with Phoenix ROM BIOS PLUS, version 
1.10.   No manual seed value was entered; and, on
the test machine, each list took slightly more 
than 1 second to generate.  

The resulting 1600 decimal numbers were pasted into
a Statistica (R) spreadsheet for analysis.

The decimal numerical values themselves first were
examined graphically:  No important trend or other
overall feature was seen within either series
of 50; neither did there seem to be anything
systematic in the average value of random integer
by position within the list of 16.

Inspection of 50 list x 50 list scatterplots, one
for each series, showed that the lists occasionally
seemed somewhat correlated, but duplicate lists were
not found.  

A 100 x 100 Pearson r crosscorrelation table showed
that less than 5% of the entries were significant
at the 0.05 level.  The average intercorrelation
between lists, for the 3-second series, the 30-second
series, and between the 3 vs 30 second series, was
within 0.1 of 0.0 (sd within 0.03 of 0.30).   This 
suggests no important linear trend within a list,
regardless of the scheduling of the commands used
to generate successive random integer lists.

Individual list means and number-order (within
list) means were quite normally distributed,
consistent with the central limit theorem.


Then, the 16,000 individual random digits (in decimal)
were examined.   Only the lower 9 digits of a random
number in a list were kept, because the most 
significant decimal digit cannot exceed 4 for an
unsigned 32-bit integer.   A Perl script was used to
count numerals in each of the above 50-list series,
and the result again was entered into Statistica, 
this time as 10 columns, one per decimal digit
numeral, and 100 rows of list counts.   The result
was 14400 decimal numerals with, of course, expected
value 1440 each, in the entire sample of 100 lists.

+---------+--------+----------+----------+----------+
| Decimal |        | Observed | Observed | Observed |
| Numeral | Binary |  n = 100 |  n = 50  |  n = 50  |
|         |        |  Count   | (3 sec)  | (30 sec) |
+---------+--------+----------+----------+----------+
|    0    |  0000  |   1428   |    691   |    737   |
+---------+--------+----------+----------+----------+
|    1    |  0001  |   1460   |    739   |    721   |
+---------+--------+----------+----------+----------+
|    2    |  0010  |   1446   |    737   |    709   |
+---------+--------+----------+----------+----------+
|    3    |  0011  |   1405   |    704   |    701   |
+---------+--------+----------+----------+----------+
|    4    |  0100  |   1418   |    728   |    690   |
+---------+--------+----------+----------+----------+
|    5    |  0101  |   1417   |    699   |    718   |
+---------+--------+----------+----------+----------+
|    6    |  0110  |   1454   |    724   |    730   |
+---------+--------+----------+----------+----------+
|    7    |  0111  |   1481   |    740   |    741   |
+---------+--------+----------+----------+----------+
|    8    |  1000  |   1431   |    721   |    710   |
+---------+--------+----------+----------+----------+
|    9    |  1001  |   1460   |    717   |    743   |
+---------+--------+--------------------------------+
     Expected (Mean) = 1440        720        720
                   +--------------------------------+
 Approx. SD of Count =   24         17         18   |
                   +--------------------------------+

Visual inspection reveals no obvious trend or 
exception among the digit counts tabulated above.
The Pearson intercorrelations within and between the 
various lists were at chance levels.

As visible in the table above, the obtained counts
all were within two sample standard deviations of
the theoretical expectancies.  No decimal digit count
fell more than about 4% away from the expected
frequency, under the assumption of perfectly equal
likelihood among digits.


In conclusion, the program seems to produce
reasonably independent lists of fairly uniformly
distributed random integers.   Occasional use
would be expected to produce completely random
lists.

Users should be certain to understand that 
this program is supplied STRICTLY AS-IS and with
NO WARRANTY of fitness for any purpose.

The statistics above are reported accurately and
are meant to be informative, but NO WARRANTY is
expressed or implied.

-----------------------------------------------------
This freeware program is Copyright (c) 2000 by John 
Michael Williams and may be copied or redistributed 
freely for any purpose, provided the executable and 
this ReadMe file always are copied or distributed 
together.

Creator:  John Michael Williams (jwill@AstraGate.net).
          Markanix Co., P. O. Box 2697, Redwood City,
          CA 94064.

