CLHEP::RandEngineBuilder< int > Struct Template Reference

Static Public Member Functions
static unsigned int	thirtyTwoRandomBits (long &seq)

Detailed Description

template<int>
struct CLHEP::RandEngineBuilder< int >

Definition at line 245 of file RandEngine.cc.

Member Function Documentation

thirtyTwoRandomBits()

template<int >

static unsigned int CLHEP::RandEngineBuilder< int >::thirtyTwoRandomBits ( long &  seq )

inlinestatic

Definition at line 246 of file RandEngine.cc.

                                                     {               
                                                            
  static bool prepared = false;
  static unsigned int iT;
  static unsigned int iK;
  static unsigned int iS;
  static int iN;
  static double fS;
  static double fT;
                                                            
  if ( (RAND_MAX >> 31) > 0 )                               
  {                                                         
    // Here, we know that integer arithmetic is 64 bits.    
    if ( !prepared ) {                                      
      iS = (unsigned long)RAND_MAX + 1;                     
      iK = 1;                                
//    int StoK = S;                          
      int StoK = iS;          
      // The two statements below are equivalent, but some compilers
      // are getting too smart and complain about the first statement.               
      //if ( (RAND_MAX >> 32) == 0) {  
      if( (unsigned long) (RAND_MAX) <= (( (1uL) << 31 ) - 1 ) ) {
        iK = 2;                              
//      StoK = S*S;                          
        StoK = iS*iS;                        
      }                                      
      int m;                                 
      for ( m = 0; m < 64; ++m ) {           
        StoK >>= 1;                          
        if (StoK == 0) break;                
      }                                      
      iT = 1 << m;                           
      prepared = true;                       
    }                                        
    int v = 0;                               
    do {                                     
      for ( int i = 0; i < iK; ++i ) {       
        v = iS*v+rand();  ++seq;                   
      }                                      
    } while (v < iT);                        
    return v & 0xFFFFFFFF;                   
                                             
  }                                          
                                             
  else if ( (RAND_MAX >> 26) == 0 )                                       
  {                                                                       
    // Here, we know it is safe to work in terms of doubles without loss  
    // of precision, but we have no idea how many randoms we will need to 
    // generate 32 bits.                                                  
    if ( !prepared ) {                                                    
      fS = (unsigned long)RAND_MAX + 1;                                                  
      double twoTo32 = std::ldexp(1.0,32);                                     
      double StoK = fS;                                                   
      for ( iK = 1; StoK < twoTo32; StoK *= fS, iK++ ) { }                
      int m;                                                              
      fT = 1.0;                                                           
      for ( m = 0; m < 64; ++m ) {                                        
        StoK *= .5;                                                       
        if (StoK < 1.0) break;                                            
        fT *= 2.0;                                                        
      }                                                                   
      prepared = true;                                                    
    }                                                                     
    double v = 0;                                                         
    do {                                                                  
      for ( int i = 0; i < iK; ++i ) {                                    
        v = fS*v+rand(); ++seq;                                                 
      }                                                                   
    } while (v < fT);                                                     
    return ((unsigned int)v) & 0xFFFFFFFF;                                
                                                                          
  }                                                                       
  else                                                                    
  {                                                                       
    // Here, we know that 16 random bits are available from each of       
    // two random numbers.                                                
    if ( !prepared ) {                                                    
      iS = (unsigned long)RAND_MAX + 1;                                                  
      int SshiftN = iS;                                                   
      for (iN = 0; SshiftN > 1; SshiftN >>= 1, iN++) { }                  
      iN -= 17;                                                           
    prepared = true;                                                      
    }                                                                     
    unsigned int x1, x2;                                                  
    do { x1 = rand(); ++seq;} while (x1 < (1<<16) );                            
    do { x2 = rand(); ++seq;} while (x2 < (1<<16) );                            
    return x1 | (x2 << 16);                                               
  }                                                                       
                                                                          
  }                                                                       

Referenced by CLHEP::RandEngine::flat(), and CLHEP::RandEngine::operator unsigned int().

---

The documentation for this struct was generated from the following file:

• RandEngine.cc