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.