CLHEP::RandBinomial Class Reference

#include <RandBinomial.h>

Inheritance diagram for CLHEP::RandBinomial:

Public Member Functions
HepRandomEngine &	engine ()
double	fire ()
double	fire (long n, double p)
void	fireArray (const int size, double *vect)
void	fireArray (const int size, double *vect, long n, double p)
double	flat ()
double	flat (HepRandomEngine *theNewEngine)
void	flatArray (const int size, double *vect)
void	flatArray (HepRandomEngine *theNewEngine, const int size, double *vect)
std::istream &	get (std::istream &is)
std::string	name () const
double	operator() ()
double	operator() (long n, double p)
std::ostream &	put (std::ostream &os) const
	RandBinomial (HepRandomEngine &anEngine, long n=1, double p=0.5)
	RandBinomial (HepRandomEngine *anEngine, long n=1, double p=0.5)
virtual	~RandBinomial ()

Static Public Member Functions
static int	createInstance ()
static std::string	distributionName ()
static HepRandomEngine *	getTheEngine ()
static HepRandom *	getTheGenerator ()
static long	getTheSeed ()
static const long *	getTheSeeds ()
static void	getTheTableSeeds (long *seeds, int index)
static std::istream &	restoreDistState (std::istream &is)
static void	restoreEngineStatus (const char filename[]="Config.conf")
static std::istream &	restoreFullState (std::istream &is)
static std::istream &	restoreStaticRandomStates (std::istream &is)
static std::ostream &	saveDistState (std::ostream &os)
static void	saveEngineStatus (const char filename[]="Config.conf")
static std::ostream &	saveFullState (std::ostream &os)
static std::ostream &	saveStaticRandomStates (std::ostream &os)
static void	setTheEngine (HepRandomEngine *theNewEngine)
static void	setTheSeed (long seed, int lxr=3)
static void	setTheSeeds (const long *seeds, int aux=-1)
static double	shoot ()
static double	shoot (HepRandomEngine *anEngine)
static double	shoot (HepRandomEngine *anEngine, long n, double p)
static double	shoot (long n, double p)
static void	shootArray (const int size, double *vect, long n=1, double p=0.5)
static void	shootArray (HepRandomEngine *anEngine, const int size, double *vect, long n=1, double p=0.5)
static void	showEngineStatus ()

Static Protected Attributes
static const long	seedTable [215][2]

Static Private Member Functions
static double	genBinomial (HepRandomEngine *anEngine, long n, double p)

Private Attributes
long	defaultN
double	defaultP
std::shared_ptr< HepRandomEngine >	localEngine

Detailed Description

Author

Definition at line 36 of file RandBinomial.h.

Constructor & Destructor Documentation

RandBinomial() [1/2]

CLHEP::RandBinomial::RandBinomial ( HepRandomEngine &  anEngine, long  n = 1, double  p = 0.5  )

inline

RandBinomial() [2/2]

CLHEP::RandBinomial::RandBinomial ( HepRandomEngine *  anEngine, long  n = 1, double  p = 0.5  )

inline

~RandBinomial()

CLHEP::RandBinomial::~RandBinomial ( )

virtual

Definition at line 31 of file RandBinomial.cc.

                            {
}

Member Function Documentation

createInstance()

int CLHEP::HepRandom::createInstance ( )

staticinherited

Definition at line 311 of file Random.cc.

{
  return static_cast<int>( theDefaults().ensureInitialized() );
}

References CLHEP::anonymous_namespace{Random.cc}::defaults::ensureInitialized(), and CLHEP::anonymous_namespace{Random.cc}::theDefaults().

distributionName()

static std::string CLHEP::RandBinomial::distributionName ( )

inlinestatic

Definition at line 98 of file RandBinomial.h.

{return "RandBinomial";}  

engine()

HepRandomEngine & CLHEP::RandBinomial::engine ( )

virtual

Reimplemented from CLHEP::HepRandom.

Definition at line 29 of file RandBinomial.cc.

{return *localEngine;}

References localEngine.

fire() [1/2]

double CLHEP::RandBinomial::fire ( )

inline

Referenced by fireArray().

fire() [2/2]

double CLHEP::RandBinomial::fire	(	long	n,
		double	p
	)

Definition at line 44 of file RandBinomial.cc.

                                            {
  return genBinomial( localEngine.get(), n, p );
}

References genBinomial(), localEngine, and CLHEP::detail::n.

fireArray() [1/2]

void CLHEP::RandBinomial::fireArray	(	const int	size,
		double *	vect
	)

Definition at line 63 of file RandBinomial.cc.

{
  for( double* v = vect; v != vect+size; ++v )
    *v = fire(defaultN,defaultP);
}

References defaultN, defaultP, and fire().

fireArray() [2/2]

void CLHEP::RandBinomial::fireArray	(	const int	size,
		double *	vect,
		long	n,
		double	p
	)

Definition at line 69 of file RandBinomial.cc.

{
  for( double* v = vect; v != vect+size; ++v )
    *v = fire(n,p);
}

References fire(), and CLHEP::detail::n.

flat() [1/2]

double CLHEP::HepRandom::flat ( )

inherited

Definition at line 199 of file Random.cc.

{
  return theDefaults().theEngine->flat();
}

References CLHEP::anonymous_namespace{Random.cc}::theDefaults(), and CLHEP::anonymous_namespace{Random.cc}::defaults::theEngine.

Referenced by CLHEP::RandExponential::shoot().

flat() [2/2]

double CLHEP::HepRandom::flat ( HepRandomEngine *  theNewEngine )

inlineinherited

flatArray() [1/2]

void CLHEP::HepRandom::flatArray ( const int  size, double *  vect  )

inherited

Definition at line 204 of file Random.cc.

{
  theDefaults().theEngine->flatArray(size,vect);
}

References CLHEP::anonymous_namespace{Random.cc}::theDefaults(), and CLHEP::anonymous_namespace{Random.cc}::defaults::theEngine.

flatArray() [2/2]

void CLHEP::HepRandom::flatArray ( HepRandomEngine *  theNewEngine, const int  size, double *  vect  )

inlineinherited

genBinomial()

double CLHEP::RandBinomial::genBinomial ( HepRandomEngine *  anEngine, long  n, double  p  )

staticprivate

Definition at line 127 of file RandBinomial.cc.

{
/******************************************************************
 *                                                                *
 *     Binomial-Distribution - Acceptance Rejection/Inversion     *
 *                                                                *
 ******************************************************************
 *                                                                *
 * Acceptance Rejection method combined with Inversion for        *
 * generating Binomial random numbers with parameters             *
 * n (number of trials) and p (probability of success).           *
 * For  min(n*p,n*(1-p)) < 10  the Inversion method is applied:   *
 * The random numbers are generated via sequential search,        *
 * starting at the lowest index k=0. The cumulative probabilities *
 * are avoided by using the technique of chop-down.               *
 * For  min(n*p,n*(1-p)) >= 10  Acceptance Rejection is used:     *
 * The algorithm is based on a hat-function which is uniform in   *
 * the centre region and exponential in the tails.                *
 * A triangular immediate acceptance region in the centre speeds  *
 * up the generation of binomial variates.                        *
 * If candidate k is near the mode, f(k) is computed recursively  *
 * starting at the mode m.                                        *
 * The acceptance test by Stirling's formula is modified          *
 * according to W. Hoermann (1992): The generation of binomial    *
 * random variates, to appear in J. Statist. Comput. Simul.       *
 * If  p < .5  the algorithm is applied to parameters n, p.       *
 * Otherwise p is replaced by 1-p, and k is replaced by n - k.    *
 *                                                                *
 ******************************************************************
 *                                                                *
 * FUNCTION:    - btpec samples a random number from the binomial *
 *                distribution with parameters n and p  and is    *
 *                valid for  n*min(p,1-p)  >  0.                  *
 * REFERENCE:   - V. Kachitvichyanukul, B.W. Schmeiser (1988):    *
 *                Binomial random variate generation,             *
 *                Communications of the ACM 31, 216-222.          *
 * SUBPROGRAMS: - StirlingCorrection()                            *
 *                            ... Correction term of the Stirling *
 *                                approximation for log(k!)       *
 *                                (series in 1/k or table values  *
 *                                for small k) with long int k    *
 *              - anEngine    ... Pointer to a (0,1)-Uniform      * 
 *                                engine                          *
 *                                                                *
 * Implemented by H. Zechner and P. Busswald, September 1992      *
 ******************************************************************/
 
#define C1_3     0.33333333333333333
#define C5_8     0.62500000000000000
#define C1_6     0.16666666666666667
#define DMAX_KM  20L
 
  static CLHEP_THREAD_LOCAL long int      n_last = -1L,  n_prev = -1L;
  static CLHEP_THREAD_LOCAL double        par,np,p0,q,p_last = -1.0, p_prev = -1.0;
  static CLHEP_THREAD_LOCAL long          b,m,nm;
  static CLHEP_THREAD_LOCAL double        pq, rc, ss, xm, xl, xr, ll, lr, c,
                 p1, p2, p3, p4, ch;
 
  long                 bh,i, K, Km, nK;
  double               f, rm, U, V, X, T, E;
 
  if (n != n_last || p != p_last)                 // set-up 
    {
     n_last = n;
     p_last = p;
     par=std::min(p,1.0-p);
     q=1.0-par;
     np = n*par;
 
// Check for invalid input values
 
     if( np <= 0.0 ) return (-1.0);
 
     rm = np + par;
     m  = (long int) rm;                      // mode, integer 
     if (np<10)
    {
     p0=std::exp(n*std::log(q));              // Chop-down
     bh=(long int)(np+10.0*std::sqrt(np*q));
     b=std::min(n,bh);
    }
     else
         {
    rc = (n + 1.0) * (pq = par / q);          // recurr. relat.
    ss = np * q;                              // variance  
    i  = (long int) (2.195*std::sqrt(ss) - 4.6*q); // i = p1 - 0.5
    xm = m + 0.5;
    xl = (double) (m - i);                    // limit left 
    xr = (double) (m + i + 1L);               // limit right
    f  = (rm - xl) / (rm - xl*par);  ll = f * (1.0 + 0.5*f);
    f  = (xr - rm) / (xr * q);     lr = f * (1.0 + 0.5*f);
    c  = 0.134 + 20.5/(15.3 + (double) m);    // parallelogram
                          // height
    p1 = i + 0.5;
    p2 = p1 * (1.0 + c + c);                  // probabilities
    p3 = p2 + c/ll;                           // of regions 1-4
    p4 = p3 + c/lr;
         }
  }
  if( np <= 0.0 ) return (-1.0);
  if (np<10)                                      //Inversion Chop-down
     {
      double pk;
 
      K=0;
      pk=p0;
      U=anEngine->flat();
      while (U>pk)
        {
         ++K;
         if (K>b)
             {
        U=anEngine->flat();
        K=0;
        pk=p0;
             }
         else
             {
        U-=pk;
        pk=(double)(((n-K+1)*par*pk)/(K*q));
             }
        }
      return ((p>0.5) ? (double)(n-K):(double)K);
     }
 
  for (;;)
    {
     V = anEngine->flat();
     if ((U = anEngine->flat() * p4) <= p1)  // triangular region
        {
         K=(long int) (xm - U + p1*V);
    return ((p>0.5) ? (double)(n-K):(double)K);  // immediate accept
        }
     if (U <= p2)                                // parallelogram
        {
         X = xl + (U - p1)/c;
         if ((V = V*c + 1.0 - std::fabs(xm - X)/p1) >= 1.0)  continue;
         K = (long int) X;
        }
     else if (U <= p3)                           // left tail
        {
         if ((X = xl + std::log(V)/ll) < 0.0)  continue;
         K = (long int) X;
         V *= (U - p2) * ll;
        }
     else                                         // right tail
        {
         if ((K = (long int) (xr - std::log(V)/lr)) > n)  continue;
         V *= (U - p3) * lr;
        }
 
 // acceptance test :  two cases, depending on |K - m|
     if ((Km = std::labs(K - m)) <= DMAX_KM || Km + Km + 2L >= ss)
      {
 
 // computation of p(K) via recurrence relationship from the mode
        f = 1.0;                              // f(m)
        if (m < K)
     {
      for (i = m; i < K; )
        {
        if ((f *= (rc / ++i - pq)) < V)  break;  // multiply  f
        }
     }
        else
     {
      for (i = K; i < m; )
         {
          if ((V *= (rc / ++i - pq)) > f)  break; // multiply  V
         }
     }
        if (V <= f)  break;                       // acceptance test
     }
  else
     {
 
 // lower and upper squeeze tests, based on lower bounds for log p(K)
        V = std::log(V);
        T = - Km * Km / (ss + ss);
        E =  (Km / ss) * ((Km * (Km * C1_3 + C5_8) + C1_6) / ss + 0.5);
        if (V <= T - E)  break;
        if (V <= T + E)
         {
    if (n != n_prev || par != p_prev)
     {
      n_prev = n;
      p_prev = par;
 
      nm = n - m + 1L;
      ch = xm * std::log((m + 1.0)/(pq * nm)) +
           StirlingCorrection(m + 1L) + StirlingCorrection(nm);
     }
    nK = n - K + 1L;
 
 // computation of log f(K) via Stirling's formula
 // final acceptance-rejection test
    if (V <= ch + (n + 1.0)*std::log((double) nm / (double) nK) +
                 (K + 0.5)*std::log(nK * pq / (K + 1.0)) -
                 StirlingCorrection(K + 1L) - StirlingCorrection(nK))  break;
        }
     }
  }
  return ((p>0.5) ? (double)(n-K):(double)K);
}

References C1_3, C1_6, C5_8, CLHEP_THREAD_LOCAL, DMAX_KM, CLHEP::HepRandomEngine::flat(), CLHEP::m, G4INCL::Math::min(), CLHEP::detail::n, CLHEP::nm, CLHEP::StirlingCorrection(), and anonymous_namespace{G4PionRadiativeDecayChannel.cc}::xl.

Referenced by fire(), and shoot().

get()

std::istream & CLHEP::RandBinomial::get ( std::istream &  is )

virtual

Reimplemented from CLHEP::HepRandom.

Definition at line 343 of file RandBinomial.cc.

                                                 {
  std::string inName;
  is >> inName;
  if (inName != name()) {
    is.clear(std::ios::badbit | is.rdstate());
    std::cerr << "Mismatch when expecting to read state of a "
              << name() << " distribution\n"
          << "Name found was " << inName
          << "\nistream is left in the badbit state\n";
    return is;
  }
  if (possibleKeywordInput(is, "Uvec", defaultN)) {
    std::vector<unsigned long> t(2);
    is >> defaultN >> defaultP;
    is >> t[0] >> t[1]; defaultP = DoubConv::longs2double(t); 
    return is;
  }
  // is >> defaultN encompassed by possibleKeywordInput
  is >> defaultP;
  return is;
}

References defaultN, defaultP, CLHEP::DoubConv::longs2double(), name(), and CLHEP::possibleKeywordInput().

getTheEngine()

HepRandomEngine * CLHEP::HepRandom::getTheEngine ( )

staticinherited

Definition at line 268 of file Random.cc.

{
  return theDefaults().theEngine.get();
}

References CLHEP::anonymous_namespace{Random.cc}::theDefaults(), and CLHEP::anonymous_namespace{Random.cc}::defaults::theEngine.

Referenced by CLHEP::StaticRandomStates::restore(), CLHEP::RandFlat::restoreEngineStatus(), CLHEP::RandGauss::restoreEngineStatus(), CLHEP::RandFlat::saveEngineStatus(), CLHEP::RandGauss::saveEngineStatus(), CLHEP::RandExponential::shoot(), CLHEP::RandExpZiggurat::shoot(), CLHEP::RandFlat::shoot(), CLHEP::RandGauss::shoot(), CLHEP::RandGaussZiggurat::shoot(), CLHEP::RandChiSquare::shoot(), CLHEP::RandStudentT::shoot(), CLHEP::RandBreitWigner::shoot(), CLHEP::RandGamma::shoot(), CLHEP::RandPoisson::shoot(), CLHEP::RandPoissonQ::shoot(), shoot(), and CLHEP::RandFlat::shootArray().

getTheGenerator()

HepRandom * CLHEP::HepRandom::getTheGenerator ( )

staticinherited

Definition at line 263 of file Random.cc.

{
  return theDefaults().theGenerator.get();
}

References CLHEP::anonymous_namespace{Random.cc}::theDefaults(), and CLHEP::anonymous_namespace{Random.cc}::defaults::theGenerator.

getTheSeed()

long CLHEP::HepRandom::getTheSeed ( )

staticinherited

Definition at line 239 of file Random.cc.

{
  return theDefaults().theEngine->getSeed();
}

References CLHEP::anonymous_namespace{Random.cc}::theDefaults(), and CLHEP::anonymous_namespace{Random.cc}::defaults::theEngine.

getTheSeeds()

const long * CLHEP::HepRandom::getTheSeeds ( )

staticinherited

Definition at line 249 of file Random.cc.

{
  return theDefaults().theEngine->getSeeds();
}

References CLHEP::anonymous_namespace{Random.cc}::theDefaults(), and CLHEP::anonymous_namespace{Random.cc}::defaults::theEngine.

getTheTableSeeds()

void CLHEP::HepRandom::getTheTableSeeds ( long *  seeds, int  index  )

staticinherited

Definition at line 254 of file Random.cc.

{
  if ((index >= 0) && (index < 215)) {
    seeds[0] = seedTable[index][0];
    seeds[1] = seedTable[index][1];
  }
  else seeds = NULL;
}

Referenced by CLHEP::HepJamesRandom::HepJamesRandom(), CLHEP::MTwistEngine::MTwistEngine(), CLHEP::RanecuEngine::RanecuEngine(), CLHEP::Ranlux64Engine::Ranlux64Engine(), CLHEP::RanluxEngine::RanluxEngine(), and CLHEP::RanecuEngine::setSeed().

name()

std::string CLHEP::RandBinomial::name ( ) const

virtual

Reimplemented from CLHEP::HepRandom.

Definition at line 28 of file RandBinomial.cc.

{return "RandBinomial";}

Referenced by source.g4viscp.G4Scene::create_scene(), get(), mcscore.MCParticle::printout(), put(), and source.g4viscp.G4Scene::update_scene().

operator()() [1/2]

double CLHEP::RandBinomial::operator() ( )

inlinevirtual

Reimplemented from CLHEP::HepRandom.

operator()() [2/2]

double CLHEP::RandBinomial::operator() ( long  n, double  p  )

inline

put()

std::ostream & CLHEP::RandBinomial::put ( std::ostream &  os ) const

virtual

Reimplemented from CLHEP::HepRandom.

Definition at line 332 of file RandBinomial.cc.

                                                       {
  int pr=os.precision(20);
  std::vector<unsigned long> t(2);
  os << " " << name() << "\n";
  os << "Uvec" << "\n";
  t = DoubConv::dto2longs(defaultP);
  os << defaultN << " " << defaultP << " " << t[0] << " " << t[1] << "\n";
  os.precision(pr);
  return os;
}

References defaultN, defaultP, CLHEP::DoubConv::dto2longs(), and name().

restoreDistState()

static std::istream & CLHEP::HepRandom::restoreDistState ( std::istream &  is )

inlinestaticinherited

Definition at line 136 of file Random.h.

{return is;}

restoreEngineStatus()

void CLHEP::HepRandom::restoreEngineStatus ( const char  filename[] = "Config.conf" )

staticinherited

Definition at line 283 of file Random.cc.

{
  theDefaults().theEngine->restoreStatus( filename );
}

References CLHEP::anonymous_namespace{Random.cc}::theDefaults(), and CLHEP::anonymous_namespace{Random.cc}::defaults::theEngine.

restoreFullState()

std::istream & CLHEP::HepRandom::restoreFullState ( std::istream &  is )

staticinherited

Definition at line 293 of file Random.cc.

                                                          {
  is >> *getTheEngine();
  return is;
}

Referenced by CLHEP::RandFlat::restoreFullState(), and CLHEP::RandGauss::restoreFullState().

restoreStaticRandomStates()

std::istream & CLHEP::HepRandom::restoreStaticRandomStates ( std::istream &  is )

staticinherited

Definition at line 302 of file Random.cc.

                                                                   {
  return StaticRandomStates::restore(is);
}

References CLHEP::StaticRandomStates::restore().

saveDistState()

static std::ostream & CLHEP::HepRandom::saveDistState ( std::ostream &  os )

inlinestaticinherited

Definition at line 133 of file Random.h.

{return os;}

saveEngineStatus()

void CLHEP::HepRandom::saveEngineStatus ( const char  filename[] = "Config.conf" )

staticinherited

Definition at line 278 of file Random.cc.

{
  theDefaults().theEngine->saveStatus( filename );
}

References CLHEP::anonymous_namespace{Random.cc}::theDefaults(), and CLHEP::anonymous_namespace{Random.cc}::defaults::theEngine.

Referenced by G4CascadeInterface::ApplyYourself(), G4HadronicProcess::PostStepDoIt(), and G4CascadeInterface::Propagate().

saveFullState()

std::ostream & CLHEP::HepRandom::saveFullState ( std::ostream &  os )

staticinherited

Definition at line 288 of file Random.cc.

                                                       {
  os << *getTheEngine();
  return os;
}

Referenced by G4EventManager::DoProcessing(), G4EventManager::ProcessOneEvent(), CLHEP::RandFlat::saveFullState(), and CLHEP::RandGauss::saveFullState().

saveStaticRandomStates()

std::ostream & CLHEP::HepRandom::saveStaticRandomStates ( std::ostream &  os )

staticinherited

Definition at line 298 of file Random.cc.

                                                                {
  return StaticRandomStates::save(os);
}

References CLHEP::StaticRandomStates::save().

setTheEngine()

void CLHEP::HepRandom::setTheEngine ( HepRandomEngine *  theNewEngine )

staticinherited

Definition at line 273 of file Random.cc.

{
  theDefaults().theEngine.reset( theNewEngine, do_nothing_deleter() );
}

References CLHEP::anonymous_namespace{Random.cc}::theDefaults(), and CLHEP::anonymous_namespace{Random.cc}::defaults::theEngine.

Referenced by CLHEP::StaticRandomStates::restore().

setTheSeed()

void CLHEP::HepRandom::setTheSeed ( long  seed, int  lxr = 3  )

staticinherited

Definition at line 234 of file Random.cc.

{
  theDefaults().theEngine->setSeed(seed,lux);
}

References CLHEP::lux, CLHEP::anonymous_namespace{Random.cc}::theDefaults(), and CLHEP::anonymous_namespace{Random.cc}::defaults::theEngine.

setTheSeeds()

void CLHEP::HepRandom::setTheSeeds ( const long *  seeds, int  aux = -1  )

staticinherited

Definition at line 244 of file Random.cc.

{
  theDefaults().theEngine->setSeeds(seeds,aux);
}

References CLHEP::anonymous_namespace{Random.cc}::theDefaults(), and CLHEP::anonymous_namespace{Random.cc}::defaults::theEngine.

shoot() [1/4]

static double CLHEP::RandBinomial::shoot ( )

inlinestatic

Referenced by shootArray().

shoot() [2/4]

static double CLHEP::RandBinomial::shoot ( HepRandomEngine *  anEngine )

inlinestatic

shoot() [3/4]

double CLHEP::RandBinomial::shoot ( HepRandomEngine *  anEngine, long  n, double  p  )

static

Definition at line 34 of file RandBinomial.cc.

                                                                     {
  return genBinomial( anEngine, n, p );
}

References genBinomial(), and CLHEP::detail::n.

shoot() [4/4]

double CLHEP::RandBinomial::shoot ( long  n, double  p  )

static

Definition at line 39 of file RandBinomial.cc.

                                             {
  HepRandomEngine *anEngine = HepRandom::getTheEngine();
  return genBinomial( anEngine, n, p );
}

References genBinomial(), CLHEP::HepRandom::getTheEngine(), and CLHEP::detail::n.

shootArray() [1/2]

void CLHEP::RandBinomial::shootArray ( const int  size, double *  vect, long  n = 1, double  p = 0.5  )

static

Definition at line 48 of file RandBinomial.cc.

{
  for( double* v = vect; v != vect+size; ++v )
    *v = shoot(n,p);
}

References CLHEP::detail::n, and shoot().

shootArray() [2/2]

void CLHEP::RandBinomial::shootArray ( HepRandomEngine *  anEngine, const int  size, double *  vect, long  n = 1, double  p = 0.5  )

static

Definition at line 55 of file RandBinomial.cc.

{
  for( double* v = vect; v != vect+size; ++v )
    *v = shoot(anEngine,n,p);
}

References CLHEP::detail::n, and shoot().

showEngineStatus()

void CLHEP::HepRandom::showEngineStatus ( )

staticinherited

Definition at line 306 of file Random.cc.

{
  theDefaults().theEngine->showStatus();
}

References CLHEP::anonymous_namespace{Random.cc}::theDefaults(), and CLHEP::anonymous_namespace{Random.cc}::defaults::theEngine.

Field Documentation

defaultN

long CLHEP::RandBinomial::defaultN

private

Definition at line 106 of file RandBinomial.h.

Referenced by fireArray(), get(), and put().

defaultP

double CLHEP::RandBinomial::defaultP

private

Definition at line 107 of file RandBinomial.h.

Referenced by fireArray(), get(), and put().

localEngine

std::shared_ptr<HepRandomEngine> CLHEP::RandBinomial::localEngine

private

Definition at line 105 of file RandBinomial.h.

Referenced by engine(), and fire().

seedTable

const long CLHEP::HepRandom::seedTable

staticprotectedinherited

Definition at line 156 of file Random.h.

---

The documentation for this class was generated from the following files:

• source/externals/clhep/include/CLHEP/Random/RandBinomial.h
• source/externals/clhep/src/RandBinomial.cc