class TRandom: public TNamed

default constructor*-*-*-*-
*-*                  ===================

default destructor*-*-*-*-
*-*                  ==================

 Generates a random integer N according to the binomial law
 Coded from Los Alamos report LA-5061-MS

 N is binomially distributed between 0 and ntot inclusive
 with mean prob*ntot.
 prob is between 0 and 1.

 Note: This function should not be used when ntot is large (say >100).
 The normal approximation is then recommended instead
 (with mean =*ntot+0.5 and standard deviation sqrt(ntot*prob*(1-prob)).

  Return a number distributed following a BreitWigner function with mean and gamma

 generates random vectors, uniformly distributed over a circle of given radius.
   Input : r = circle radius
   Output: x,y a random 2-d vector of length r

 returns an exponential deviate.

          exp( -t/tau )

  samples a random number from the standard Normal (Gaussian) Distribution
  with the given mean and sigma.
  Uses the Acceptance-complement ratio from W. Hoermann and G. Derflinger
  This is one of the fastest existing method for generating normal random variables.
  It is a factor 2/3 faster than the polar (Box-Muller) method used in the previous
  version of TRandom::Gaus. The speed is comparable to the Ziggurat method (from Marsaglia)
  implemented for example in GSL and available in the MathMore library.


  REFERENCE:  - W. Hoermann and G. Derflinger (1990):
               The ACR Method for generating normal random variables,
               OR Spektrum 12 (1990), 181-185.

  Implementation taken from
   UNURAN (c) 2000  W. Hoermann & J. Leydold, Institut f. Statistik, WU Wien

  returns a random integer on [ 0, imax-1 ].

  Generate a random number following a Landau distribution
  with mpv(most probable value) and sigma
  Use function landau_quantile(x,sigma) which provides
  the inverse of the landau cumulative distribution
  landau_quantile has been converted from CERNLIB ranlan(G110)

 Generates a random integer N according to a Poisson law.
 Prob(N) = exp(-mean)*mean^N/Factorial(N)

 Use a different procedure according to the mean value.
 The algorithm is the same used by CLHEP
 For lower value (mean < 25) use the rejection method based on
 the exponential
 For higher values use a rejection method comparing with a Lorentzian
 distribution, as suggested by several authors
 This routine since is returning 32 bits integer will not work for values larger than 2*10**9
 One should then use the Trandom::PoissonD for such large values

 Generates a random number according to a Poisson law.
 Prob(N) = exp(-mean)*mean^N/Factorial(N)

 This function is a variant of TRandom::Poisson returning a double
 instead of an integer.

      Return 2 numbers distributed following a gaussian with mean=0 and sigma=1

      Return 2 numbers distributed following a gaussian with mean=0 and sigma=1

 Reads saved random generator status from filename

  Machine independent random number generator.
  Based on the BSD Unix (Rand) Linear congrential generator
  Produces uniformly-distributed floating points between 0 and 1.
  Identical sequence on all machines of >= 32 bits.
  Periodicity = 2**31
  generates a number in ]0,1]
  Note that this is a generator which is known to have defects
  (the lower random bits are correlated) and therefore should NOT be
  used in any statistical study.

 Return an array of n random numbers uniformly distributed in ]0,1]

 Return an array of n random numbers uniformly distributed in ]0,1]

  Set the random generator seed. Note that default value is zero, which is different than the
  default value used when constructing the class.
  If the seed is zero the seed is set to a random value
  which in case of TRandom depends on the  machine clock.
  Note that the machine clock is returned with a precision of 1 second.
  If one calls SetSeed(0) within a loop and the loop time is less than 1s,
  all generated numbers will be identical!
  Instead if a different generator implementation is used (TRandom1 , 2 or 3) the seed is generated using
  a 128 bit UUID. This results in different seeds and then random sequence for every SetSeed(0) call.

 generates random vectors, uniformly distributed over the surface
 of a sphere of given radius.
   Input : r = sphere radius
   Output: x,y,z a random 3-d vector of length r
 Method:  (based on algorithm suggested by Knuth and attributed to Robert E Knop)
          which uses less random numbers than the CERNLIB RN23DIM algorithm

 returns a uniform deviate on the interval  ]0, x1].

 returns a uniform deviate on the interval ]x1, x2].

 Writes random generator status to filename