Suppose – let us just suppose- you want to create random numbers that are reproducible , and derived from time stamps

Here is the code in R

> a=as.numeric(Sys.time())

> set.seed(a)

> rnorm(log(a))

Note- you can create a custom function ( I used the log) for generating random numbers of the system time too. This creates a random numbered list of pseudo random numbers (since nothing machine driven is purely random in the strict philosophy of the word)

a=as.numeric(Sys.time())

set.seed(a)

abs(100000000*rnorm(abs(log(a))))

[1] 39621645 99451316 109889294 110275233 278994547 6554596 38654159 68748122 8920823 13293010

[11] 57664241 24533980 174529340 105304151 168006526 39173857 12810354 145341412 241341095 86568818

[21] 105672257

Possible applications- things that need both random numbers (like encryption keys) and time stamps (like events , web or industrial logs or as pseudo random pass codes in Google 2 factor authentication )

Note I used the rnorm function but you could possibly draw the functions also as a random input (rnorm or rcauchy)

Again I would trust my own random ness than one generated by an arm of US Govt (see http://www.nist.gov/itl/csd/ct/nist_beacon.cfm )

Update- Random numbers in R

http://stat.ethz.ch/R-manual/R-patched/library/base/html/Random.html

### Details

The currently available RNG kinds are given below. `kind`

is partially matched to this list. The default is `"Mersenne-Twister"`

.

`"Wichmann-Hill"`

- The seed,
`.Random.seed[-1] == r[1:3]`

is an integer vector of length 3, where each `r[i]`

is in `1:(p[i] - 1)`

, where `p`

is the length 3 vector of primes, `p = (30269, 30307, 30323)`

. The Wichmann–Hill generator has a cycle length of *6.9536e12* (= `prod(p-1)/4`

, see *Applied Statistics* (1984) **33**, 123 which corrects the original article).
`"Marsaglia-Multicarry"`

:
- A
*multiply-with-carry* RNG is used, as recommended by George Marsaglia in his post to the mailing list ‘sci.stat.math’. It has a period of more than *2^60* and has passed all tests (according to Marsaglia). The seed is two integers (all values allowed).
`"Super-Duper"`

:
- Marsaglia’s famous Super-Duper from the 70’s. This is the original version which does
*not* pass the MTUPLE test of the Diehard battery. It has a period of *about 4.6*10^18* for most initial seeds. The seed is two integers (all values allowed for the first seed: the second must be odd).
We use the implementation by Reeds et al. (1982–84).

The two seeds are the Tausworthe and congruence long integers, respectively. A one-to-one mapping to S’s `.Random.seed[1:12]`

is possible but we will not publish one, not least as this generator is **not** exactly the same as that in recent versions of S-PLUS.

`"Mersenne-Twister":`

- From Matsumoto and Nishimura (1998). A twisted GFSR with period
*2^19937 – 1* and equidistribution in 623 consecutive dimensions (over the whole period). The ‘seed’ is a 624-dimensional set of 32-bit integers plus a current position in that set.
`"Knuth-TAOCP-2002":`

- A 32-bit integer GFSR using lagged Fibonacci sequences with subtraction. That is, the recurrence used is
*X[j] = (X[j-100] – X[j-37]) mod 2^30*

and the ‘seed’ is the set of the 100 last numbers (actually recorded as 101 numbers, the last being a cyclic shift of the buffer). The period is around *2^129*.

`"Knuth-TAOCP":`

- An earlier version from Knuth (1997).
The 2002 version was not backwards compatible with the earlier version: the initialization of the GFSR from the seed was altered. **R** did not allow you to choose consecutive seeds, the reported ‘weakness’, and already scrambled the seeds.

Initialization of this generator is done in interpreted **R** code and so takes a short but noticeable time.

`"L'Ecuyer-CMRG":`

- A ‘combined multiple-recursive generator’ from L’Ecuyer (1999), each element of which is a feedback multiplicative generator with three integer elements: thus the seed is a (signed) integer vector of length 6. The period is around
*2^191*.
The 6 elements of the seed are internally regarded as 32-bit unsigned integers. Neither the first three nor the last three should be all zero, and they are limited to less than `4294967087`

and `4294944443`

respectively.

This is not particularly interesting of itself, but provides the basis for the multiple streams used in package parallel.

`"user-supplied":`

- Use a user-supplied generator.

Function `RNGkind`

allows user-coded uniform and normal random number generators to be supplied.

28.635308
77.224960