library: libCore
#include "TRandom.h"


class description - header file - source file
viewCVS header - viewCVS source

class TRandom: public TNamed

Inheritance Inherited Members Includes Libraries
Class Charts

Function Members (Methods)

Display options:
Show inherited
Show non-public
TRandom(UInt_t seed = 65539)
TRandom(const TRandom&)
voidTObject::AbstractMethod(const char* method) const
virtual voidTObject::AppendPad(Option_t* option = "")
virtual Int_tBinomial(Int_t ntot, Double_t prob)
virtual Double_tBreitWigner(Double_t mean = 0, Double_t gamma = 1)
virtual voidTObject::Browse(TBrowser* b)
virtual voidCircle(Double_t& x, Double_t& y, Double_t r)
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual voidTNamed::Clear(Option_t* option = "")
virtual TObject*TNamed::Clone(const char* newname = "") const
virtual Int_tTNamed::Compare(const TObject* obj) const
virtual voidTNamed::Copy(TObject& named) const
virtual voidTObject::Delete(Option_t* option = "")
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
virtual voidTObject::Draw(Option_t* option = "")
virtual voidTObject::DrawClass() const
virtual TObject*TObject::DrawClone(Option_t* option = "") const
virtual voidTObject::Dump() const
virtual voidTObject::Error(const char* method, const char* msgfmt) const
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual voidTObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual Double_tExp(Double_t tau)
virtual voidTObject::Fatal(const char* method, const char* msgfmt) const
virtual voidTNamed::FillBuffer(char*& buffer)
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
virtual Double_tGaus(Double_t mean = 0, Double_t sigma = 1)
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
virtual const char*TObject::GetIconName() const
virtual const char*TNamed::GetName() const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual Option_t*TObject::GetOption() const
virtual UInt_tGetSeed()
virtual const char*TNamed::GetTitle() const
virtual UInt_tTObject::GetUniqueID() const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual ULong_tTNamed::Hash() const
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
virtual voidTObject::Inspect() const
virtual UInt_tInteger(UInt_t imax)
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tTObject::IsFolder() const
Bool_tTObject::IsOnHeap() const
virtual Bool_tTNamed::IsSortable() const
Bool_tTObject::IsZombie() const
virtual Double_tLandau(Double_t mean = 0, Double_t sigma = 1)
virtual voidTNamed::ls(Option_t* option = "") const
voidTObject::MayNotUse(const char* method) const
virtual Bool_tTObject::Notify()
static voidTObject::operator delete(void* ptr)
static voidTObject::operator delete(void* ptr, void* vp)
static voidTObject::operator delete[](void* ptr)
static voidTObject::operator delete[](void* ptr, void* vp)
void*TObject::operator new(size_t sz)
void*TObject::operator new(size_t sz, void* vp)
void*TObject::operator new[](size_t sz)
void*TObject::operator new[](size_t sz, void* vp)
TRandom&operator=(const TRandom&)
virtual voidTObject::Paint(Option_t* option = "")
virtual Int_tPoisson(Double_t mean)
virtual Double_tPoissonD(Double_t mean)
virtual voidTObject::Pop()
virtual voidTNamed::Print(Option_t* option = "") const
virtual voidRannor(Float_t& a, Float_t& b)
virtual voidRannor(Double_t& a, Double_t& b)
virtual Int_tTObject::Read(const char* name)
virtual voidReadRandom(const char* filename)
virtual voidTObject::RecursiveRemove(TObject* obj)
voidTObject::ResetBit(UInt_t f)
virtual Double_tRndm(Int_t i = 0)
virtual voidRndmArray(Int_t n, Float_t* array)
virtual voidRndmArray(Int_t n, Double_t* array)
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") const
virtual voidTObject::SavePrimitive(ostream& out, Option_t* option = "")
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
virtual voidTObject::SetDrawOption(Option_t* option = "")
static voidTObject::SetDtorOnly(void* obj)
virtual voidTNamed::SetName(const char* name)
virtual voidTNamed::SetNameTitle(const char* name, const char* title)
static voidTObject::SetObjectStat(Bool_t stat)
virtual voidSetSeed(UInt_t seed = 65539)
virtual voidTNamed::SetTitle(const char* title = "")
virtual voidTObject::SetUniqueID(UInt_t uid)
virtual voidShowMembers(TMemberInspector& insp, char* parent)
virtual Int_tTNamed::Sizeof() const
virtual voidSphere(Double_t& x, Double_t& y, Double_t& z, Double_t r)
virtual voidStreamer(TBuffer& b)
voidStreamerNVirtual(TBuffer& b)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
virtual Double_tUniform(Double_t x1 = 1)
virtual Double_tUniform(Double_t x1, Double_t x2)
virtual voidTObject::UseCurrentStyle()
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual Int_tTObject::Write(const char* name = "0", Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTObject::Write(const char* name = "0", Int_t option = 0, Int_t bufsize = 0) const
virtual voidWriteRandom(const char* filename)
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const

Data Members

enum TObject::EStatusBits { kCanDelete
enum TObject::[unnamed] { kIsOnHeap
UInt_tfSeedRandom number generator seed
TStringTNamed::fNameobject identifier
TStringTNamed::fTitleobject title

Class Description


 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:

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

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

     TF1 *f1 = new TF1("f1","gaus",-4,4);
     for (i=0;i<N;i++) {
        x = f1->GetRandom();
     printf("GausTF1........... %8.3f\n",sw.CpuTime()*cpn);

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


TRandom(UInt_t seed)
*-*-*-*-*-*-*-*-*-*-*default constructor*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
*-*                  ===================
*-*-*-*-*-*-*-*-*-*-*default destructor*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
*-*                  ==================
Int_t 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)).
Double_t BreitWigner(Double_t mean, Double_t gamma)
  Return a number distributed following a BreitWigner function with mean and gamma
void 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 Exp(Double_t tau)
 returns an exponential deviate.

          exp( -t/tau )
Double_t Gaus(Double_t mean, Double_t sigma)
      Return a number distributed following a gaussian with mean and sigma
UInt_t Integer(UInt_t imax)
  returns a random integer on [ 0, imax-1 ].
Double_t Landau(Double_t mpv, Double_t sigma)
  Generate a random number following a Landau distribution
  with mpv(most probable value) and sigma
  Converted by Rene Brun from CERNLIB routine ranlan(G110)
Int_t 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

Double_t 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.

void Rannor(Float_t &a, Float_t &b)
      Return 2 numbers distributed following a gaussian with mean=0 and sigma=1
void Rannor(Double_t &a, Double_t &b)
      Return 2 numbers distributed following a gaussian with mean=0 and sigma=1
void ReadRandom(const char *filename)
 Reads saved random generator status from filename

Double_t 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. 
void RndmArray(Int_t n, Double_t *array)
 Return an array of n random numbers uniformly distributed in ]0,1]
void RndmArray(Int_t n, Float_t *array)
 Return an array of n random numbers uniformly distributed in ]0,1]
void SetSeed(UInt_t seed)
  Set the random generator seed
  if seed is zero, the seed is set to the current  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!
void 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 Uniform(Double_t x1)
 returns a uniform deviate on the interval  ]0, x1].
Double_t Uniform(Double_t x1, Double_t x2)
 returns a uniform deviate on the interval ]x1, x2].
void WriteRandom(const char *filename)
 Writes random generator status to filename

TRandom(UInt_t seed=65539)
UInt_t GetSeed()
{return fSeed;}

Author: Rene Brun, Lorenzo Moneta 15/12/95
Last update: root/base:$Name: $:$Id: TRandom.cxx,v 1.34 2006/12/11 10:44:21 brun Exp $
Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *

ROOT page - Class index - Class Hierarchy - 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.