runifS               package:accuracy               R Documentation

_F_u_n_c_t_i_o_n _t_o _r_e_t_u_r_n _T_R_U_E (_n_o_t _p_s_e_u_d_o) _r_a_n_d_o_m _n_u_m_b_e_r_s, _b_a_s_e_d _o_n _s_y_s_t_e_m _a_n_d _n_e_t_w_o_r_k_e_d _e_n_t_r_o_p_y _c_o_l_l_e_c_t_i_o_n.

_D_e_s_c_r_i_p_t_i_o_n:

     This function makes use of hardware-generated entropy to supply 
     true random numbers. Entropy collection is slow, so its primary
     use to provide random numbers for cryptographic key generation and
     for setting  the seed value for subsequent PRNG generation.

_U_s_a_g_e:

             runifT(n,min=0,max=1,maxTries=10,silent=TRUE)
             runifS(n,...,period=10000,maxTries=10,silent=TRUE)
             rnormS(n,...,period=10000,maxTries=10,silent=TRUE)
             rstarMix(n,...,period=10000,maxTries=10,silent=TRUE,rfunc="runif")
             resetSeed(maxTries=10,silent=TRUE,kind=NULL,normal.kind=NULL)

_A_r_g_u_m_e_n_t_s:

       n: number of observations. If 'length(n) > 1', the length is
          taken to be the number required. 

 min,max: lower and upper limits of the distribution 

     ...: pass on to runif

  period: number of random numbers to generate before reseeding

maxTries: number of times to attempt to contact entropy source before
          giving yp

  silent: whether to report failures of entropy source generators

   rfunc: random deviate function to use

    kind: sets the kind of random number generator as per 'set.seed'

normal.kind: sets the kind of random number generator as per 'set.seed'

_D_e_t_a_i_l_s:

     'runifS' returns uniform pseudo-random numbers, reseeding with a
     true random number every period draws. 'rnormS' returns normal
     pseudo-random numbers, reseeding with a true random number every
     period draws. 'rstarMix' returns random numbers from any specified
     random number deviant generating function, reseeding with a true
     random number every period draws. 'rnormS' and 'runifS' are simply
     wrappers around this function 'resetSeed' resets R's own PRNG
     seed, 'set.seed', supplying a true random number

     'runifT' returns true random numbers in a uniform distribution.
     This can easily exhaust entropy sources, so for larger samples,
     'runifS' is usually preferred.

     These routines  provides true random numbers by accessing external
     entropy collectors. Currently entropy can be retrieved from two
     different sources. (1) The "Hotbits" server <URL:
     http://www.fourmilab.ch/hotbits/> supplies random bytes based on
     radioactive decay. (2) The bit server on random.org, and (3) On
     Unix systems, the the  kernel gathers environmental noise from
     device drivers and other sources into an entropy  pool, which can
     be accessed through '/dev/random'.

     Entropy is retrieved in blocks from the sources (each source
     having a different preferred block size). If the sources do not
     return a block within the R timeout value (see
     'options("timeout")' entropy requests will be repeated up to
     maxTries times per source. If no entropy is available, pseudo
     random numbers will be returned using 'runif()' (or a seed will be
     set based on 'Sys.time', for 'resetSeed', and a warning issued.

_V_a_l_u_e:

     'runifS,runifT'    Returns a vector of uniformly distributed true
     random numbers. 'resetSeed' returns the status of 'set.seed()'

_A_u_t_h_o_r(_s):

     Micah Altman Micah_Altman@harvard.edu <URL:
     http://www.hmdc.harvard.edu/micah_altman/>

_R_e_f_e_r_e_n_c_e_s:

     Altman, M., J. Gill and M. P. McDonald.  2003.  _Numerical Issues
     in Statistical Computing for the Social Scientist_.  John Wiley &
     Sons. <URL: http://www.hmdc.harvard.edu/numerical_issues/>

_S_e_e _A_l_s_o:

     See Also  'runif', 'options', '.Random.seed',

_E_x_a_m_p_l_e_s:

     # note, if you are using Windows, you must be on-line
     # to get to entropy generator, will fall-back to pseudo-random
     # numbers when off-line



     # reset the seed for runif() based on a true random value

     resetSeed()
     y=runif(100000)
     ty= table(trunc(5*y))
     print(ty)
     if (is.R()) {
       chisq.test(ty)
     } else {
       chisq.test(t(cbind(as.numeric(names(ty)),as.matrix(ty))))
     }

     ## Not run: 
     # generate true random values directly (may block for long periods if 
     # if entropy pool is empty)
     y=runifS(100000)
     ty= table(trunc(5*y))
     print(ty)
     if (is.R()) {
       chisq.test(ty)
     } else {
       chisq.test(t(cbind(as.numeric(names(ty)),as.matrix(ty))))
     }

     y=runifT(100)
     ty= table(trunc(5*y))
     print(ty);
     chisq.test(ty)
     ## End(Not run)

