TRandom


class description - source file - inheritance tree

class TRandom : public TNamed


    public:
TRandom TRandom(UInt_t seed = 65539) TRandom TRandom(TRandom&) virtual void ~TRandom() virtual Int_t Binomial(Int_t ntot, Float_t prob) TClass* Class() virtual Float_t Gaus(Float_t mean = 0, Float_t sigma = 1) virtual UInt_t GetSeed() virtual TClass* IsA() const virtual Float_t Landau(Float_t mean = 0, Float_t sigma = 1) virtual Int_t Poisson(Float_t mean) virtual void Rannor(Float_t& a, Float_t& b) virtual Float_t Rndm(Int_t i = 0) virtual void SetSeed(UInt_t seed = 65539) virtual void ShowMembers(TMemberInspector& insp, char* parent) virtual void Streamer(TBuffer& b)

Data Members

protected:
UInt_t fSeed Random number generator seed


See also

TRandom2, TRandom3

Class Description

 TRandom

 basic Random number generator class (periodicity = 10**8).

 The following basic Random generators are provided:
 ===================================================
   -Gaus(mean,sigma)
   -Rndm()
   -Landau(mean,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);
   float r = f1->GetRandom();
 The technique of using a TF1,2 or 3 function is very powerful.
 It is also more precise than using the basic functions (except Rndm).
 With a TF1 function, for example, the real integral of the function
 is correctly calculated in the specified range of the function.
 Getting a number from a TF1 function is also very fast.
 The following table shows some timings (in microsecons/call)
 for basic functions and TF1 functions.
 The left column is with the compiler, the right column with CINT.
 Numbers have been obtained on a Pentium 233Mhz running Linux.

                          g++        CINT
   Rndm..............    0.330       4.15
   Gaus..............    2.220       6.77
   Landau............   21.590      46.82
   Binomial(5,0.5)...    0.890       5.34
   Binomial(15,0.5)..    0.920       5.36
   Poisson(3)........    2.170       5.93
   Poisson(10).......    4.160       7.95
   Poisson(70).......   21.510      25.27
   Poisson(100)......    2.910       6.72
   GausTF1...........    2.070       4.73
   LandauTF1.........    2.100       4.73

  Note that the time to generate a number from an arbitrary TF1 function
  is independent of the complexity of the function.
  For Landau distribution, it is recommended to use the TF1 technique.

  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");

  The small program below has been used to get the values in the table above.
   #ifndef __CINT__
      #include "TROOT.h"
   #include "TF1.h"
   #include "TRandom.h"
   #include "TStopwatch.h"
   void rand();

   //______________________________________________________________________________
   int main()
   {
     TROOT simple("simple","Test of random numbers");

     rand();
   }
   #endif
   void rand() {
     int i, N = 1000000;
     float cpn = 1000000./N;
     float x;
     TStopwatch sw;
     sw.Start();
     for (i=0;i<N;i++) {
        x = gRandom->Rndm(i);
     }
     printf("Rndm.............. %8.3f microseconds/calln",sw.CpuTime()*cpn);
     sw.Start();
     for (i=0;i<N;i++) {
        x = gRandom->Gaus(0,1);
     }
     printf("Gaus.............. %8.3fn",sw.CpuTime()*cpn);
     sw.Start();
     for (i=0;i<N;i++) {
        x = gRandom->Landau(0,1);
     }
     printf("Landau............ %8.3fn",sw.CpuTime()*cpn);
     sw.Start();
     for (i=0;i<N;i++) {
        x = gRandom->Binomial(5,0.5);
     }
     printf("Binomial(5,0.5)... %8.3fn",sw.CpuTime()*cpn);
     sw.Start();
     for (i=0;i<N;i++) {
        x = gRandom->Binomial(15,0.5);
     }
     printf("Binomial(15,0.5).. %8.3fn",sw.CpuTime()*cpn);
     sw.Start();
     for (i=0;i<N;i++) {
        x = gRandom->Poisson(3);
     }
     printf("Poisson(3)........ %8.3fn",sw.CpuTime()*cpn);
     sw.Start();
     for (i=0;i<N;i++) {
        x = gRandom->Poisson(10);
     }
     printf("Poisson(10)....... %8.3fn",sw.CpuTime()*cpn);
     sw.Start();
     for (i=0;i<N;i++) {
        x = gRandom->Poisson(70);
     }
     printf("Poisson(70)....... %8.3fn",sw.CpuTime()*cpn);
     sw.Start();
     for (i=0;i<N;i++) {
        x = gRandom->Poisson(100);
     }
     printf("Poisson(100)...... %8.3fn",sw.CpuTime()*cpn);

     TF1 *f1 = new TF1("f1","gaus",-4,4);
     f1->SetParameters(1,0,1);
     sw.Start();
     for (i=0;i<N;i++) {
        x = f1->GetRandom();
     }
     printf("GausTF1........... %8.3fn",sw.CpuTime()*cpn);

     TF1 *f2 = new TF1("f2","landau",-5,15);
     f2->SetParameters(1,0,1);
     sw.Start();
     for (i=0;i<N;i++) {
        x = f2->GetRandom();
     }
     printf("LandauTF1......... %8.3fn",sw.CpuTime()*cpn);

   }


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

~TRandom()
*-*-*-*-*-*-*-*-*-*-*default destructor*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
*-*                  ==================

Int_t Binomial(Int_t ntot, Float_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)).

Float_t Gaus(Float_t mean, Float_t sigma)
      Return a number distributed following a gaussian with mean and sigma

Float_t Landau(Float_t mean, Float_t sigma)
  Generate a random number following a Landau distribution
  with average value mean and rms
  Converted by Rene Brun from CERNLIB routine ranlan(G110)

Int_t Poisson(Float_t mean)
 Generates a random integer N according to a Poisson law.
 Coded from Los Alamos report LA-5061-MS
 Prob(N) = exp(-mean)*mean^N/Factorial(N)


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

Float_t Rndm(Int_t)
  Machine independent random number generator.
  Produces uniformly-distributed floating points between 0 and 1.
  Identical sequence on all machines of >= 32 bits.
  Periodicity = 10**8
  Universal version (Fred james 1985).

void SetSeed(UInt_t seed)
  Set the random generator seed
  if seed is zero, the seed is set to the current  machine clock



Inline Functions


             UInt_t GetSeed()
            TClass* Class()
            TClass* IsA() const
               void ShowMembers(TMemberInspector& insp, char* parent)
               void Streamer(TBuffer& b)
            TRandom TRandom(TRandom&)


Author: Rene Brun 15/12/95
Last update: 2.21/07 09/06/99 11.45.19 by Rene Brun
Copyright (c) 1995-1999, The ROOT System, All rights reserved. *


ROOT page - Class index - Top of the page

This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.