ROOT logo
// @(#)root/mathcore:$Id: TRandom.cxx 41909 2011-11-11 14:46:39Z pcanal $
// Author: Rene Brun, Lorenzo Moneta   15/12/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

//////////////////////////////////////////////////////////////////////////
//
// TRandom
//
// basic Random number generator class (periodicity = 10**9).
// Note that this is a very simple generator (linear congruential)
// which is known to have defects (the lower random bits are correlated)
// and therefore should NOT be used in any statistical study.
// One should use instead TRandom1, TRandom2 or TRandom3.
// TRandom3, is based on the "Mersenne Twister generator", and is the recommended one,
// since it has good random proprieties (period of about 10**6000 ) and it is fast.
// TRandom1, based on the RANLUX algorithm, has mathematically proven random proprieties
// and a period of about 10**171. It is however slower than the others.
// TRandom2, is based on the Tausworthe generator of L'Ecuyer, and it has the advantage
// of being fast and using only 3 words (of 32 bits) for the state. The period is 10**26.
//
// The following table shows some timings (in nanoseconds/call)
// for the random numbers obtained using an Intel Pentium 3.0 GHz running Linux
// and using the gcc 3.2.3 compiler
//
//    TRandom           34   ns/call     (BAD Generator)
//    TRandom1          242  ns/call
//    TRandom2          37   ns/call
//    TRandom3          45   ns/call
//
//
// The following basic Random distributions are provided:
// ===================================================
//   -Exp(tau)
//   -Integer(imax)
//   -Gaus(mean,sigma)
//   -Rndm()
//   -Uniform(x1)
//   -Landau(mpv,sigma)
//   -Poisson(mean)
//   -Binomial(ntot,prob)
//
// Random numbers distributed according to 1-d, 2-d or 3-d distributions
// =====================================================================
// contained in TF1, TF2 or TF3 objects.
// For example, to get a random number distributed following abs(sin(x)/x)*sqrt(x)
// you can do :
//   TF1 *f1 = new TF1("f1","abs(sin(x)/x)*sqrt(x)",0,10);
//   double r = f1->GetRandom();
// or you can use the UNURAN package. You need in this case to initialize UNURAN 
// to the function you would like to generate. 
//   TUnuran u; 
//   u.Init(TUnuranDistrCont(f1)); 
//   double r = u.Sample();
//
// The techniques of using directly a TF1,2 or 3 function is powerful and 
// can be used to generate numbers in the defined range of the function. 
// Getting a number from a TF1,2,3 function is also quite fast.
// UNURAN is a  powerful and flexible tool which containes various methods for 
// generate random numbers for continuous distributions of one and multi-dimension. 
// It requires some set-up (initialization) phase and can be very fast when the distribution 
// parameters are not changed for every call.   
//
// The following table shows some timings (in nanosecond/call)
// for basic functions,  TF1 functions and using UNURAN obtained running 
// the tutorial math/testrandom.C
// Numbers have been obtained on an Intel Xeon Quad-core Harpertown (E5410) 2.33 GHz running 
// Linux SLC4 64 bit and compiled with gcc 3.4
//
// Distribution            nanoseconds/call
//                     TRandom  TRandom1 TRandom2 TRandom3
// Rndm..............    5.000  105.000    7.000   10.000
// RndmArray.........    4.000  104.000    6.000    9.000
// Gaus..............   36.000  180.000   40.000   48.000
// Rannor............  118.000  220.000  120.000  124.000
// Landau............   22.000  123.000   26.000   31.000
// Exponential.......   93.000  198.000   98.000  104.000
// Binomial(5,0.5)...   30.000  548.000   46.000   65.000
// Binomial(15,0.5)..   75.000 1615.000  125.000  178.000
// Poisson(3)........   96.000  494.000  109.000  125.000
// Poisson(10).......  138.000 1236.000  165.000  203.000
// Poisson(70).......  818.000 1195.000  835.000  844.000
// Poisson(100)......  837.000 1218.000  849.000  864.000
// GausTF1...........   83.000  180.000   87.000   88.000
// LandauTF1.........   80.000  180.000   83.000   86.000
// GausUNURAN........   40.000  139.000   41.000   44.000
// PoissonUNURAN(10).   85.000  271.000   92.000  102.000
// PoissonUNURAN(100)   62.000  256.000   69.000   78.000
//
//  Note that the time to generate a number from an arbitrary TF1 function 
//  using TF1::GetRandom or using TUnuran is  independent of the complexity of the function.
//
//  TH1::FillRandom(TH1 *) or TH1::FillRandom(const char *tf1name)
//  ==============================================================
//  can be used to fill an histogram (1-d, 2-d, 3-d from an existing histogram
//  or from an existing function.
//
//  Note this interesting feature when working with objects
//  =======================================================
//  You can use several TRandom objects, each with their "independent"
//  random sequence. For example, one can imagine
//     TRandom *eventGenerator = new TRandom();
//     TRandom *tracking       = new TRandom();
//  eventGenerator can be used to generate the event kinematics.
//  tracking can be used to track the generated particles with random numbers
//  independent from eventGenerator.
//  This very interesting feature gives the possibility to work with simple
//  and very fast random number generators without worrying about
//  random number periodicity as it was the case with Fortran.
//  One can use TRandom::SetSeed to modify the seed of one generator.
//
//  a TRandom object may be written to a Root file
//  ==============================================
//    -as part of another object
//    -or with its own key (example gRandom->Write("Random");
//
//////////////////////////////////////////////////////////////////////////

#include "TROOT.h"
#include "TMath.h"
#include "TRandom.h"
#include "TRandom3.h"
#include "TSystem.h"
#include "TDirectory.h"
#include "Math/QuantFuncMathCore.h"
#include <time.h>

ClassImp(TRandom)

//______________________________________________________________________________
TRandom::TRandom(UInt_t seed): TNamed("Random","Default Random number generator")
{
//*-*-*-*-*-*-*-*-*-*-*default constructor*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
//*-*                  ===================

   SetSeed(seed);

}

//______________________________________________________________________________
TRandom::~TRandom()
{
//*-*-*-*-*-*-*-*-*-*-*default destructor*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
//*-*                  ==================

if (gRandom == this) gRandom = 0;
}

//______________________________________________________________________________
Int_t TRandom::Binomial(Int_t ntot, Double_t prob)
{
// 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)).

   if (prob < 0 || prob > 1) return 0;
   Int_t n = 0;
   for (Int_t i=0;i<ntot;i++) {
      if (Rndm() > prob) continue;
      n++;
   }
   return n;
}

//______________________________________________________________________________
Double_t TRandom::BreitWigner(Double_t mean, Double_t gamma)
{
//  Return a number distributed following a BreitWigner function with mean and gamma

   Double_t rval, displ;
   rval = 2*Rndm() - 1;
   displ = 0.5*gamma*TMath::Tan(rval*TMath::PiOver2());

   return (mean+displ);
}

//______________________________________________________________________________
void TRandom::Circle(Double_t &x, Double_t &y, Double_t r)
{
   // 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

   Double_t phi = Uniform(0,TMath::TwoPi());
   x = r*TMath::Cos(phi);
   y = r*TMath::Sin(phi);
}

//______________________________________________________________________________
Double_t TRandom::Exp(Double_t tau)
{
// returns an exponential deviate.
//
//          exp( -t/tau )

   Double_t x = Rndm();              // uniform on ] 0, 1 ]
   Double_t t = -tau * TMath::Log( x ); // convert to exponential distribution
   return t;
}

//______________________________________________________________________________
Double_t TRandom::Gaus(Double_t mean, Double_t sigma)
{
//               
//  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 
///////////////////////////////////////////////////////////////////////////////



   const Double_t kC1 = 1.448242853;
   const Double_t kC2 = 3.307147487;
   const Double_t kC3 = 1.46754004;
   const Double_t kD1 = 1.036467755;
   const Double_t kD2 = 5.295844968;
   const Double_t kD3 = 3.631288474;
   const Double_t kHm = 0.483941449;
   const Double_t kZm = 0.107981933;
   const Double_t kHp = 4.132731354;
   const Double_t kZp = 18.52161694;
   const Double_t kPhln = 0.4515827053;
   const Double_t kHm1 = 0.516058551;
   const Double_t kHp1 = 3.132731354;
   const Double_t kHzm = 0.375959516;
   const Double_t kHzmp = 0.591923442;
   /*zhm 0.967882898*/

   const Double_t kAs = 0.8853395638;
   const Double_t kBs = 0.2452635696;
   const Double_t kCs = 0.2770276848;
   const Double_t kB  = 0.5029324303;
   const Double_t kX0 = 0.4571828819;
   const Double_t kYm = 0.187308492 ;
   const Double_t kS  = 0.7270572718 ;
   const Double_t kT  = 0.03895759111;

   Double_t result;
   Double_t rn,x,y,z;


   do {
      y = Rndm();

      if (y>kHm1) {
         result = kHp*y-kHp1; break; }
  
      else if (y<kZm) {  
         rn = kZp*y-1;
         result = (rn>0) ? (1+rn) : (-1+rn);
         break;
      } 

      else if (y<kHm) {  
         rn = Rndm();
         rn = rn-1+rn;
         z = (rn>0) ? 2-rn : -2-rn;
         if ((kC1-y)*(kC3+TMath::Abs(z))<kC2) {
            result = z; break; }
         else {  
            x = rn*rn;
            if ((y+kD1)*(kD3+x)<kD2) {
               result = rn; break; }
            else if (kHzmp-y<exp(-(z*z+kPhln)/2)) {
               result = z; break; }
            else if (y+kHzm<exp(-(x+kPhln)/2)) {
               result = rn; break; }
         }
      }

      while (1) {
         x = Rndm();
         y = kYm * Rndm();
         z = kX0 - kS*x - y;
         if (z>0) 
            rn = 2+y/x;
         else {
            x = 1-x;
            y = kYm-y;
            rn = -(2+y/x);
         }
         if ((y-kAs+x)*(kCs+x)+kBs<0) {
            result = rn; break; }
         else if (y<x+kT)
            if (rn*rn<4*(kB-log(x))) {
               result = rn; break; }
      }
   } while(0);


   return mean + sigma * result;

} 



//______________________________________________________________________________
UInt_t TRandom::Integer(UInt_t imax)
{
//  returns a random integer on [ 0, imax-1 ].

   UInt_t ui;
   ui = (UInt_t)(imax*Rndm());
   return ui;
}

//______________________________________________________________________________
Double_t TRandom::Landau(Double_t mpv, Double_t sigma)
{
//  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) 

   if (sigma <= 0) return 0;
   Double_t x = Rndm(); 
   Double_t res = mpv + ROOT::Math::landau_quantile(x, sigma);
   return res;
}

//______________________________________________________________________________
Int_t TRandom::Poisson(Double_t mean)
{
// 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
//
   Int_t n;
   if (mean <= 0) return 0;
   if (mean < 25) {
      Double_t expmean = TMath::Exp(-mean);
      Double_t pir = 1;
      n = -1;
      while(1) {
         n++;
         pir *= Rndm();
         if (pir <= expmean) break;
      }
      return n;
   }
   // for large value we use inversion method
   else if (mean < 1E9) {
      Double_t em, t, y;
      Double_t sq, alxm, g;
      Double_t pi = TMath::Pi();

      sq = TMath::Sqrt(2.0*mean);
      alxm = TMath::Log(mean);
      g = mean*alxm - TMath::LnGamma(mean + 1.0);

      do {
         do {
            y = TMath::Tan(pi*Rndm());
            em = sq*y + mean;
         } while( em < 0.0 );

         em = TMath::Floor(em);
         t = 0.9*(1.0 + y*y)* TMath::Exp(em*alxm - TMath::LnGamma(em + 1.0) - g);
      } while( Rndm() > t );

      return static_cast<Int_t> (em);

   }
   else {
      // use Gaussian approximation vor very large values
      n = Int_t(Gaus(0,1)*TMath::Sqrt(mean) + mean +0.5);
      return n;
   }
}

//______________________________________________________________________________
Double_t TRandom::PoissonD(Double_t mean)
{
// 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.
//
   Int_t n;
   if (mean <= 0) return 0;
   if (mean < 25) {
      Double_t expmean = TMath::Exp(-mean);
      Double_t pir = 1;
      n = -1;
      while(1) {
         n++;
         pir *= Rndm();
         if (pir <= expmean) break;
      }
      return static_cast<Double_t>(n);
   }
   // for large value we use inversion method
   else if (mean < 1E9) {
      Double_t em, t, y;
      Double_t sq, alxm, g;
      Double_t pi = TMath::Pi();

      sq = TMath::Sqrt(2.0*mean);
      alxm = TMath::Log(mean);
      g = mean*alxm - TMath::LnGamma(mean + 1.0);

      do {
         do {
            y = TMath::Tan(pi*Rndm());
            em = sq*y + mean;
         } while( em < 0.0 );

         em = TMath::Floor(em);
         t = 0.9*(1.0 + y*y)* TMath::Exp(em*alxm - TMath::LnGamma(em + 1.0) - g);
      } while( Rndm() > t );

      return em;

   } else {
      // use Gaussian approximation vor very large values
      return Gaus(0,1)*TMath::Sqrt(mean) + mean +0.5;
   }
}

//______________________________________________________________________________
void TRandom::Rannor(Float_t &a, Float_t &b)
{
//      Return 2 numbers distributed following a gaussian with mean=0 and sigma=1

   Double_t r, x, y, z;

   y = Rndm();
   z = Rndm();
   x = z * 6.28318530717958623;
   r = TMath::Sqrt(-2*TMath::Log(y));
   a = (Float_t)(r * TMath::Sin(x));
   b = (Float_t)(r * TMath::Cos(x));
}

//______________________________________________________________________________
void TRandom::Rannor(Double_t &a, Double_t &b)
{
//      Return 2 numbers distributed following a gaussian with mean=0 and sigma=1

   Double_t r, x, y, z;

   y = Rndm();
   z = Rndm();
   x = z * 6.28318530717958623;
   r = TMath::Sqrt(-2*TMath::Log(y));
   a = r * TMath::Sin(x);
   b = r * TMath::Cos(x);
}

//_____________________________________________________________________________
void TRandom::ReadRandom(const char *filename)
{
   //
   // Reads saved random generator status from filename
   //
   if (!gDirectory) return;
   char *fntmp = gSystem->ExpandPathName(filename);
   TDirectory *file = (TDirectory*)gROOT->ProcessLine(Form("TFile::Open(\"%s\");",fntmp));
   delete [] fntmp;
   if(file && file->GetFile()) {
      gDirectory->ReadTObject(this,GetName());
      delete file;
   }
}

//______________________________________________________________________________
Double_t TRandom::Rndm(Int_t)
{
//  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.

#ifdef OLD_TRANDOM_IMPL
   const Double_t kCONS = 4.6566128730774E-10;
   const Int_t kMASK24  = 2147483392;

   fSeed *= 69069;
   UInt_t jy = (fSeed&kMASK24); // Set lower 8 bits to zero to assure exact float
   if (jy) return kCONS*jy;
   return Rndm();
#endif

   const Double_t kCONS = 4.6566128730774E-10; // (1/pow(2,31))
   fSeed = (1103515245 * fSeed + 12345) & 0x7fffffffUL;

   if (fSeed) return  kCONS*fSeed;
   return Rndm();
}

//______________________________________________________________________________
void TRandom::RndmArray(Int_t n, Double_t *array)
{
   // Return an array of n random numbers uniformly distributed in ]0,1]

   const Double_t kCONS = 4.6566128730774E-10; // (1/pow(2,31))
   Int_t i=0;
   while (i<n) {
      fSeed = (1103515245 * fSeed + 12345) & 0x7fffffffUL;
      if (fSeed) {array[i] = kCONS*fSeed; i++;}
   }
}

//______________________________________________________________________________
void TRandom::RndmArray(Int_t n, Float_t *array)
{
   // Return an array of n random numbers uniformly distributed in ]0,1]

   const Double_t kCONS = 4.6566128730774E-10; // (1/pow(2,31))
   Int_t i=0;
   while (i<n) {
      fSeed = (1103515245 * fSeed + 12345) & 0x7fffffffUL;
      if (fSeed) {array[i] = Float_t(kCONS*fSeed); i++;}
   }
}

//______________________________________________________________________________
void TRandom::SetSeed(UInt_t seed)
{
//  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. 

   if( seed==0 ) {
      time_t curtime;      // Set 'random' seed number  if seed=0
      time(&curtime);      // Get current time in fSeed.
      fSeed = (UInt_t)curtime;
   } else {
      fSeed = seed;
   }
}

//______________________________________________________________________________
void TRandom::Sphere(Double_t &x, Double_t &y, Double_t &z, Double_t r)
{
   // 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

   Double_t a=0,b=0,r2=1;
   while (r2 > 0.25) {
      a  = Rndm() - 0.5;
      b  = Rndm() - 0.5;
      r2 =  a*a + b*b;
   }
   z = r* ( -1. + 8.0 * r2 );

   Double_t scale = 8.0 * r * TMath::Sqrt(0.25 - r2);
   x = a*scale;
   y = b*scale;
}

//______________________________________________________________________________
Double_t TRandom::Uniform(Double_t x1)
{
// returns a uniform deviate on the interval  ]0, x1].

   Double_t ans = Rndm();
   return x1*ans;
}

//______________________________________________________________________________
Double_t TRandom::Uniform(Double_t x1, Double_t x2)
{
// returns a uniform deviate on the interval ]x1, x2].

   Double_t ans= Rndm();
   return x1 + (x2-x1)*ans;
}

//_____________________________________________________________________________
void TRandom::WriteRandom(const char *filename)
{
   //
   // Writes random generator status to filename
   //
   if (!gDirectory) return;
   char *fntmp = gSystem->ExpandPathName(filename);
   TDirectory *file = (TDirectory*)gROOT->ProcessLine(Form("TFile::Open(\"%s\",\"recreate\");",fntmp));
   delete [] fntmp;
   if(file && file->GetFile()) {
      gDirectory->WriteTObject(this,GetName());
      delete file;
   }
}
 TRandom.cxx:1
 TRandom.cxx:2
 TRandom.cxx:3
 TRandom.cxx:4
 TRandom.cxx:5
 TRandom.cxx:6
 TRandom.cxx:7
 TRandom.cxx:8
 TRandom.cxx:9
 TRandom.cxx:10
 TRandom.cxx:11
 TRandom.cxx:12
 TRandom.cxx:13
 TRandom.cxx:14
 TRandom.cxx:15
 TRandom.cxx:16
 TRandom.cxx:17
 TRandom.cxx:18
 TRandom.cxx:19
 TRandom.cxx:20
 TRandom.cxx:21
 TRandom.cxx:22
 TRandom.cxx:23
 TRandom.cxx:24
 TRandom.cxx:25
 TRandom.cxx:26
 TRandom.cxx:27
 TRandom.cxx:28
 TRandom.cxx:29
 TRandom.cxx:30
 TRandom.cxx:31
 TRandom.cxx:32
 TRandom.cxx:33
 TRandom.cxx:34
 TRandom.cxx:35
 TRandom.cxx:36
 TRandom.cxx:37
 TRandom.cxx:38
 TRandom.cxx:39
 TRandom.cxx:40
 TRandom.cxx:41
 TRandom.cxx:42
 TRandom.cxx:43
 TRandom.cxx:44
 TRandom.cxx:45
 TRandom.cxx:46
 TRandom.cxx:47
 TRandom.cxx:48
 TRandom.cxx:49
 TRandom.cxx:50
 TRandom.cxx:51
 TRandom.cxx:52
 TRandom.cxx:53
 TRandom.cxx:54
 TRandom.cxx:55
 TRandom.cxx:56
 TRandom.cxx:57
 TRandom.cxx:58
 TRandom.cxx:59
 TRandom.cxx:60
 TRandom.cxx:61
 TRandom.cxx:62
 TRandom.cxx:63
 TRandom.cxx:64
 TRandom.cxx:65
 TRandom.cxx:66
 TRandom.cxx:67
 TRandom.cxx:68
 TRandom.cxx:69
 TRandom.cxx:70
 TRandom.cxx:71
 TRandom.cxx:72
 TRandom.cxx:73
 TRandom.cxx:74
 TRandom.cxx:75
 TRandom.cxx:76
 TRandom.cxx:77
 TRandom.cxx:78
 TRandom.cxx:79
 TRandom.cxx:80
 TRandom.cxx:81
 TRandom.cxx:82
 TRandom.cxx:83
 TRandom.cxx:84
 TRandom.cxx:85
 TRandom.cxx:86
 TRandom.cxx:87
 TRandom.cxx:88
 TRandom.cxx:89
 TRandom.cxx:90
 TRandom.cxx:91
 TRandom.cxx:92
 TRandom.cxx:93
 TRandom.cxx:94
 TRandom.cxx:95
 TRandom.cxx:96
 TRandom.cxx:97
 TRandom.cxx:98
 TRandom.cxx:99
 TRandom.cxx:100
 TRandom.cxx:101
 TRandom.cxx:102
 TRandom.cxx:103
 TRandom.cxx:104
 TRandom.cxx:105
 TRandom.cxx:106
 TRandom.cxx:107
 TRandom.cxx:108
 TRandom.cxx:109
 TRandom.cxx:110
 TRandom.cxx:111
 TRandom.cxx:112
 TRandom.cxx:113
 TRandom.cxx:114
 TRandom.cxx:115
 TRandom.cxx:116
 TRandom.cxx:117
 TRandom.cxx:118
 TRandom.cxx:119
 TRandom.cxx:120
 TRandom.cxx:121
 TRandom.cxx:122
 TRandom.cxx:123
 TRandom.cxx:124
 TRandom.cxx:125
 TRandom.cxx:126
 TRandom.cxx:127
 TRandom.cxx:128
 TRandom.cxx:129
 TRandom.cxx:130
 TRandom.cxx:131
 TRandom.cxx:132
 TRandom.cxx:133
 TRandom.cxx:134
 TRandom.cxx:135
 TRandom.cxx:136
 TRandom.cxx:137
 TRandom.cxx:138
 TRandom.cxx:139
 TRandom.cxx:140
 TRandom.cxx:141
 TRandom.cxx:142
 TRandom.cxx:143
 TRandom.cxx:144
 TRandom.cxx:145
 TRandom.cxx:146
 TRandom.cxx:147
 TRandom.cxx:148
 TRandom.cxx:149
 TRandom.cxx:150
 TRandom.cxx:151
 TRandom.cxx:152
 TRandom.cxx:153
 TRandom.cxx:154
 TRandom.cxx:155
 TRandom.cxx:156
 TRandom.cxx:157
 TRandom.cxx:158
 TRandom.cxx:159
 TRandom.cxx:160
 TRandom.cxx:161
 TRandom.cxx:162
 TRandom.cxx:163
 TRandom.cxx:164
 TRandom.cxx:165
 TRandom.cxx:166
 TRandom.cxx:167
 TRandom.cxx:168
 TRandom.cxx:169
 TRandom.cxx:170
 TRandom.cxx:171
 TRandom.cxx:172
 TRandom.cxx:173
 TRandom.cxx:174
 TRandom.cxx:175
 TRandom.cxx:176
 TRandom.cxx:177
 TRandom.cxx:178
 TRandom.cxx:179
 TRandom.cxx:180
 TRandom.cxx:181
 TRandom.cxx:182
 TRandom.cxx:183
 TRandom.cxx:184
 TRandom.cxx:185
 TRandom.cxx:186
 TRandom.cxx:187
 TRandom.cxx:188
 TRandom.cxx:189
 TRandom.cxx:190
 TRandom.cxx:191
 TRandom.cxx:192
 TRandom.cxx:193
 TRandom.cxx:194
 TRandom.cxx:195
 TRandom.cxx:196
 TRandom.cxx:197
 TRandom.cxx:198
 TRandom.cxx:199
 TRandom.cxx:200
 TRandom.cxx:201
 TRandom.cxx:202
 TRandom.cxx:203
 TRandom.cxx:204
 TRandom.cxx:205
 TRandom.cxx:206
 TRandom.cxx:207
 TRandom.cxx:208
 TRandom.cxx:209
 TRandom.cxx:210
 TRandom.cxx:211
 TRandom.cxx:212
 TRandom.cxx:213
 TRandom.cxx:214
 TRandom.cxx:215
 TRandom.cxx:216
 TRandom.cxx:217
 TRandom.cxx:218
 TRandom.cxx:219
 TRandom.cxx:220
 TRandom.cxx:221
 TRandom.cxx:222
 TRandom.cxx:223
 TRandom.cxx:224
 TRandom.cxx:225
 TRandom.cxx:226
 TRandom.cxx:227
 TRandom.cxx:228
 TRandom.cxx:229
 TRandom.cxx:230
 TRandom.cxx:231
 TRandom.cxx:232
 TRandom.cxx:233
 TRandom.cxx:234
 TRandom.cxx:235
 TRandom.cxx:236
 TRandom.cxx:237
 TRandom.cxx:238
 TRandom.cxx:239
 TRandom.cxx:240
 TRandom.cxx:241
 TRandom.cxx:242
 TRandom.cxx:243
 TRandom.cxx:244
 TRandom.cxx:245
 TRandom.cxx:246
 TRandom.cxx:247
 TRandom.cxx:248
 TRandom.cxx:249
 TRandom.cxx:250
 TRandom.cxx:251
 TRandom.cxx:252
 TRandom.cxx:253
 TRandom.cxx:254
 TRandom.cxx:255
 TRandom.cxx:256
 TRandom.cxx:257
 TRandom.cxx:258
 TRandom.cxx:259
 TRandom.cxx:260
 TRandom.cxx:261
 TRandom.cxx:262
 TRandom.cxx:263
 TRandom.cxx:264
 TRandom.cxx:265
 TRandom.cxx:266
 TRandom.cxx:267
 TRandom.cxx:268
 TRandom.cxx:269
 TRandom.cxx:270
 TRandom.cxx:271
 TRandom.cxx:272
 TRandom.cxx:273
 TRandom.cxx:274
 TRandom.cxx:275
 TRandom.cxx:276
 TRandom.cxx:277
 TRandom.cxx:278
 TRandom.cxx:279
 TRandom.cxx:280
 TRandom.cxx:281
 TRandom.cxx:282
 TRandom.cxx:283
 TRandom.cxx:284
 TRandom.cxx:285
 TRandom.cxx:286
 TRandom.cxx:287
 TRandom.cxx:288
 TRandom.cxx:289
 TRandom.cxx:290
 TRandom.cxx:291
 TRandom.cxx:292
 TRandom.cxx:293
 TRandom.cxx:294
 TRandom.cxx:295
 TRandom.cxx:296
 TRandom.cxx:297
 TRandom.cxx:298
 TRandom.cxx:299
 TRandom.cxx:300
 TRandom.cxx:301
 TRandom.cxx:302
 TRandom.cxx:303
 TRandom.cxx:304
 TRandom.cxx:305
 TRandom.cxx:306
 TRandom.cxx:307
 TRandom.cxx:308
 TRandom.cxx:309
 TRandom.cxx:310
 TRandom.cxx:311
 TRandom.cxx:312
 TRandom.cxx:313
 TRandom.cxx:314
 TRandom.cxx:315
 TRandom.cxx:316
 TRandom.cxx:317
 TRandom.cxx:318
 TRandom.cxx:319
 TRandom.cxx:320
 TRandom.cxx:321
 TRandom.cxx:322
 TRandom.cxx:323
 TRandom.cxx:324
 TRandom.cxx:325
 TRandom.cxx:326
 TRandom.cxx:327
 TRandom.cxx:328
 TRandom.cxx:329
 TRandom.cxx:330
 TRandom.cxx:331
 TRandom.cxx:332
 TRandom.cxx:333
 TRandom.cxx:334
 TRandom.cxx:335
 TRandom.cxx:336
 TRandom.cxx:337
 TRandom.cxx:338
 TRandom.cxx:339
 TRandom.cxx:340
 TRandom.cxx:341
 TRandom.cxx:342
 TRandom.cxx:343
 TRandom.cxx:344
 TRandom.cxx:345
 TRandom.cxx:346
 TRandom.cxx:347
 TRandom.cxx:348
 TRandom.cxx:349
 TRandom.cxx:350
 TRandom.cxx:351
 TRandom.cxx:352
 TRandom.cxx:353
 TRandom.cxx:354
 TRandom.cxx:355
 TRandom.cxx:356
 TRandom.cxx:357
 TRandom.cxx:358
 TRandom.cxx:359
 TRandom.cxx:360
 TRandom.cxx:361
 TRandom.cxx:362
 TRandom.cxx:363
 TRandom.cxx:364
 TRandom.cxx:365
 TRandom.cxx:366
 TRandom.cxx:367
 TRandom.cxx:368
 TRandom.cxx:369
 TRandom.cxx:370
 TRandom.cxx:371
 TRandom.cxx:372
 TRandom.cxx:373
 TRandom.cxx:374
 TRandom.cxx:375
 TRandom.cxx:376
 TRandom.cxx:377
 TRandom.cxx:378
 TRandom.cxx:379
 TRandom.cxx:380
 TRandom.cxx:381
 TRandom.cxx:382
 TRandom.cxx:383
 TRandom.cxx:384
 TRandom.cxx:385
 TRandom.cxx:386
 TRandom.cxx:387
 TRandom.cxx:388
 TRandom.cxx:389
 TRandom.cxx:390
 TRandom.cxx:391
 TRandom.cxx:392
 TRandom.cxx:393
 TRandom.cxx:394
 TRandom.cxx:395
 TRandom.cxx:396
 TRandom.cxx:397
 TRandom.cxx:398
 TRandom.cxx:399
 TRandom.cxx:400
 TRandom.cxx:401
 TRandom.cxx:402
 TRandom.cxx:403
 TRandom.cxx:404
 TRandom.cxx:405
 TRandom.cxx:406
 TRandom.cxx:407
 TRandom.cxx:408
 TRandom.cxx:409
 TRandom.cxx:410
 TRandom.cxx:411
 TRandom.cxx:412
 TRandom.cxx:413
 TRandom.cxx:414
 TRandom.cxx:415
 TRandom.cxx:416
 TRandom.cxx:417
 TRandom.cxx:418
 TRandom.cxx:419
 TRandom.cxx:420
 TRandom.cxx:421
 TRandom.cxx:422
 TRandom.cxx:423
 TRandom.cxx:424
 TRandom.cxx:425
 TRandom.cxx:426
 TRandom.cxx:427
 TRandom.cxx:428
 TRandom.cxx:429
 TRandom.cxx:430
 TRandom.cxx:431
 TRandom.cxx:432
 TRandom.cxx:433
 TRandom.cxx:434
 TRandom.cxx:435
 TRandom.cxx:436
 TRandom.cxx:437
 TRandom.cxx:438
 TRandom.cxx:439
 TRandom.cxx:440
 TRandom.cxx:441
 TRandom.cxx:442
 TRandom.cxx:443
 TRandom.cxx:444
 TRandom.cxx:445
 TRandom.cxx:446
 TRandom.cxx:447
 TRandom.cxx:448
 TRandom.cxx:449
 TRandom.cxx:450
 TRandom.cxx:451
 TRandom.cxx:452
 TRandom.cxx:453
 TRandom.cxx:454
 TRandom.cxx:455
 TRandom.cxx:456
 TRandom.cxx:457
 TRandom.cxx:458
 TRandom.cxx:459
 TRandom.cxx:460
 TRandom.cxx:461
 TRandom.cxx:462
 TRandom.cxx:463
 TRandom.cxx:464
 TRandom.cxx:465
 TRandom.cxx:466
 TRandom.cxx:467
 TRandom.cxx:468
 TRandom.cxx:469
 TRandom.cxx:470
 TRandom.cxx:471
 TRandom.cxx:472
 TRandom.cxx:473
 TRandom.cxx:474
 TRandom.cxx:475
 TRandom.cxx:476
 TRandom.cxx:477
 TRandom.cxx:478
 TRandom.cxx:479
 TRandom.cxx:480
 TRandom.cxx:481
 TRandom.cxx:482
 TRandom.cxx:483
 TRandom.cxx:484
 TRandom.cxx:485
 TRandom.cxx:486
 TRandom.cxx:487
 TRandom.cxx:488
 TRandom.cxx:489
 TRandom.cxx:490
 TRandom.cxx:491
 TRandom.cxx:492
 TRandom.cxx:493
 TRandom.cxx:494
 TRandom.cxx:495
 TRandom.cxx:496
 TRandom.cxx:497
 TRandom.cxx:498
 TRandom.cxx:499
 TRandom.cxx:500
 TRandom.cxx:501
 TRandom.cxx:502
 TRandom.cxx:503
 TRandom.cxx:504
 TRandom.cxx:505
 TRandom.cxx:506
 TRandom.cxx:507
 TRandom.cxx:508
 TRandom.cxx:509
 TRandom.cxx:510
 TRandom.cxx:511
 TRandom.cxx:512
 TRandom.cxx:513
 TRandom.cxx:514
 TRandom.cxx:515
 TRandom.cxx:516
 TRandom.cxx:517
 TRandom.cxx:518
 TRandom.cxx:519
 TRandom.cxx:520
 TRandom.cxx:521
 TRandom.cxx:522
 TRandom.cxx:523
 TRandom.cxx:524
 TRandom.cxx:525
 TRandom.cxx:526
 TRandom.cxx:527
 TRandom.cxx:528
 TRandom.cxx:529
 TRandom.cxx:530
 TRandom.cxx:531
 TRandom.cxx:532
 TRandom.cxx:533
 TRandom.cxx:534
 TRandom.cxx:535
 TRandom.cxx:536
 TRandom.cxx:537
 TRandom.cxx:538
 TRandom.cxx:539
 TRandom.cxx:540
 TRandom.cxx:541
 TRandom.cxx:542
 TRandom.cxx:543
 TRandom.cxx:544
 TRandom.cxx:545
 TRandom.cxx:546
 TRandom.cxx:547
 TRandom.cxx:548
 TRandom.cxx:549
 TRandom.cxx:550
 TRandom.cxx:551
 TRandom.cxx:552
 TRandom.cxx:553
 TRandom.cxx:554
 TRandom.cxx:555
 TRandom.cxx:556
 TRandom.cxx:557
 TRandom.cxx:558
 TRandom.cxx:559
 TRandom.cxx:560
 TRandom.cxx:561
 TRandom.cxx:562
 TRandom.cxx:563
 TRandom.cxx:564
 TRandom.cxx:565
 TRandom.cxx:566
 TRandom.cxx:567
 TRandom.cxx:568
 TRandom.cxx:569
 TRandom.cxx:570
 TRandom.cxx:571
 TRandom.cxx:572
 TRandom.cxx:573
 TRandom.cxx:574
 TRandom.cxx:575
 TRandom.cxx:576
 TRandom.cxx:577
 TRandom.cxx:578
 TRandom.cxx:579
 TRandom.cxx:580
 TRandom.cxx:581
 TRandom.cxx:582
 TRandom.cxx:583
 TRandom.cxx:584
 TRandom.cxx:585
 TRandom.cxx:586
 TRandom.cxx:587
 TRandom.cxx:588
 TRandom.cxx:589
 TRandom.cxx:590
 TRandom.cxx:591
 TRandom.cxx:592
 TRandom.cxx:593
 TRandom.cxx:594
 TRandom.cxx:595
 TRandom.cxx:596
 TRandom.cxx:597
 TRandom.cxx:598
 TRandom.cxx:599
 TRandom.cxx:600
 TRandom.cxx:601
 TRandom.cxx:602
 TRandom.cxx:603
 TRandom.cxx:604
 TRandom.cxx:605
 TRandom.cxx:606
 TRandom.cxx:607
 TRandom.cxx:608
 TRandom.cxx:609
 TRandom.cxx:610
 TRandom.cxx:611
 TRandom.cxx:612
 TRandom.cxx:613
 TRandom.cxx:614
 TRandom.cxx:615
 TRandom.cxx:616
 TRandom.cxx:617
 TRandom.cxx:618
 TRandom.cxx:619
 TRandom.cxx:620
 TRandom.cxx:621
 TRandom.cxx:622
 TRandom.cxx:623
 TRandom.cxx:624
 TRandom.cxx:625
 TRandom.cxx:626
 TRandom.cxx:627
 TRandom.cxx:628
 TRandom.cxx:629
 TRandom.cxx:630
 TRandom.cxx:631
 TRandom.cxx:632
 TRandom.cxx:633
 TRandom.cxx:634