CLHEP::RanluxEngine Class Reference

#include <RanluxEngine.h>

Inheritance diagram for CLHEP::RanluxEngine:

Public Member Functions
	RanluxEngine (std::istream &is)
	RanluxEngine ()
	RanluxEngine (long seed, int lux=3)
	RanluxEngine (int rowIndex, int colIndex, int lux)
virtual	~RanluxEngine ()
double	flat ()
void	flatArray (const int size, double *vect)
void	setSeed (long seed, int lux=3)
void	setSeeds (const long *seeds, int lux=3)
void	saveStatus (const char filename[]="Ranlux.conf") const
void	restoreStatus (const char filename[]="Ranlux.conf")
void	showStatus () const
int	getLuxury () const
	operator unsigned int ()
virtual std::ostream &	put (std::ostream &os) const
virtual std::istream &	get (std::istream &is)
virtual std::istream &	getState (std::istream &is)
std::string	name () const
std::vector< unsigned long >	put () const
bool	get (const std::vector< unsigned long > &v)
bool	getState (const std::vector< unsigned long > &v)
Public Member Functions inherited from CLHEP::HepRandomEngine
	HepRandomEngine ()
virtual	~HepRandomEngine ()
bool	operator== (const HepRandomEngine &engine)
bool	operator!= (const HepRandomEngine &engine)
virtual double	flat ()=0
virtual void	flatArray (const int size, double *vect)=0
virtual void	setSeed (long seed, int)=0
virtual void	setSeeds (const long *seeds, int)=0
virtual void	saveStatus (const char filename[]="Config.conf") const =0
virtual void	restoreStatus (const char filename[]="Config.conf")=0
virtual void	showStatus () const =0
virtual std::string	name () const =0
virtual std::ostream &	put (std::ostream &os) const
virtual std::istream &	get (std::istream &is)
virtual std::istream &	getState (std::istream &is)
virtual std::vector< unsigned long >	put () const
virtual bool	get (const std::vector< unsigned long > &v)
virtual bool	getState (const std::vector< unsigned long > &v)
long	getSeed () const
const long *	getSeeds () const
virtual	operator double ()
virtual	operator float ()
virtual	operator unsigned int ()

Static Public Member Functions
static std::string	beginTag ()
static std::string	engineName ()
Static Public Member Functions inherited from CLHEP::HepRandomEngine
static std::string	beginTag ()
static HepRandomEngine *	newEngine (std::istream &is)
static HepRandomEngine *	newEngine (const std::vector< unsigned long > &v)

Static Public Attributes
static const unsigned int	VECTOR_STATE_SIZE = 31

Additional Inherited Members
Static Protected Member Functions inherited from CLHEP::HepRandomEngine
static double	exponent_bit_32 ()
static double	mantissa_bit_12 ()
static double	mantissa_bit_24 ()
static double	mantissa_bit_32 ()
static double	twoToMinus_32 ()
static double	twoToMinus_48 ()
static double	twoToMinus_49 ()
static double	twoToMinus_53 ()
static double	nearlyTwoToMinus_54 ()
static bool	checkFile (std::istream &file, const std::string &filename, const std::string &classname, const std::string &methodname)
Protected Attributes inherited from CLHEP::HepRandomEngine
long	theSeed
const long *	theSeeds

Detailed Description

Author

Definition at line 45 of file RanluxEngine.h.

Constructor & Destructor Documentation

RanluxEngine() [1/4]

CLHEP::RanluxEngine::RanluxEngine

(

std::istream &

is

)

Definition at line 115 of file RanluxEngine.cc.

: HepRandomEngine()
{
  is >> *this;
}

RanluxEngine() [2/4]

CLHEP::RanluxEngine::RanluxEngine

(

)

Definition at line 73 of file RanluxEngine.cc.

: HepRandomEngine()
{
   long seed;
   long seedlist[2]={0,0};
 
   luxury = 3;
   int cycle = std::abs(int(numEngines/maxIndex));
   int curIndex = std::abs(int(numEngines%maxIndex));
   numEngines +=1;
   long mask = ((cycle & 0x007fffff) << 8);
   HepRandom::getTheTableSeeds( seedlist, curIndex );
   seed = seedlist[0]^mask;
   setSeed(seed, luxury);
   
   // setSeeds() wants a zero terminated array!
   seedlist[0]=theSeed;
   seedlist[1]=0;
   setSeeds(seedlist, luxury);
}

RanluxEngine() [3/4]

CLHEP::RanluxEngine::RanluxEngine	(	long	seed,
		int	lux = 3
	)

Definition at line 59 of file RanluxEngine.cc.

: HepRandomEngine()
{
   long seedlist[2]={0,0};
 
   luxury = lux;
   setSeed(seed, luxury);
   
   // setSeeds() wants a zero terminated array!
   seedlist[0]=theSeed;
   seedlist[1]=0;
   setSeeds(seedlist, luxury);
}

RanluxEngine() [4/4]

CLHEP::RanluxEngine::RanluxEngine	(	int	rowIndex,
		int	colIndex,
		int	lux
	)

Definition at line 94 of file RanluxEngine.cc.

: HepRandomEngine()
{
   long seed;
   long seedlist[2]={0,0};
 
   luxury = lux;
   int cycle = std::abs(int(rowIndex/maxIndex));
   int row = std::abs(int(rowIndex%maxIndex));
   int col = std::abs(int(colIndex%2));
   long mask = (( cycle & 0x000007ff ) << 20 );
   HepRandom::getTheTableSeeds( seedlist, row );
   seed = ( seedlist[col] )^mask;
   setSeed(seed, luxury);
   
   // setSeeds() wants a zero terminated array!
   seedlist[0]=theSeed;
   seedlist[1]=0;
   setSeeds(seedlist, luxury);
}

~RanluxEngine()

CLHEP::RanluxEngine::~RanluxEngine ( )

virtual

Definition at line 121 of file RanluxEngine.cc.

{}

Member Function Documentation

beginTag()

std::string CLHEP::RanluxEngine::beginTag ( )

static

Definition at line 462 of file RanluxEngine.cc.

                                    { 
  return "RanluxEngine-begin"; 
}

engineName()

static std::string CLHEP::RanluxEngine::engineName ( )

inlinestatic

Definition at line 102 of file RanluxEngine.h.

{return "RanluxEngine";}

Referenced by restoreStatus().

flat()

double CLHEP::RanluxEngine::flat ( )

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 307 of file RanluxEngine.cc.

                          {
 
  float next_random;
  float uni;
  int i;
 
  uni = float_seed_table[j_lag] - float_seed_table[i_lag] - carry;
  if(uni < 0. ){
     uni += 1.0;
     carry = mantissa_bit_24();
  }else{
     carry = 0.;
  }
 
  float_seed_table[i_lag] = uni;
  i_lag --;
  j_lag --;
  if(i_lag < 0) i_lag = 23;
  if(j_lag < 0) j_lag = 23;
 
  if( uni < mantissa_bit_12() ){
     uni += mantissa_bit_24() * float_seed_table[j_lag];
     if( uni == 0) uni = mantissa_bit_24() * mantissa_bit_24();
  }
  next_random = uni;
  count24 ++;
 
// every 24th number generation, several random numbers are generated
// and wasted depending upon the luxury level.
 
  if(count24 == 24 ){
     count24 = 0;
     for( i = 0; i != nskip ; i++){
         uni = float_seed_table[j_lag] - float_seed_table[i_lag] - carry;
         if(uni < 0. ){
            uni += 1.0;
            carry = mantissa_bit_24();
         }else{
            carry = 0.;
         }
         float_seed_table[i_lag] = uni;
     i_lag --;
         j_lag --;
         if(i_lag < 0)i_lag = 23;
         if(j_lag < 0) j_lag = 23;
      }
  } 
  return (double) next_random;
}

flatArray()

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

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 357 of file RanluxEngine.cc.

{
  float next_random;
  float uni;
  int i;
  int index;
 
  for (index=0; index<size; ++index) {
    uni = float_seed_table[j_lag] - float_seed_table[i_lag] - carry;
    if(uni < 0. ){
       uni += 1.0;
       carry = mantissa_bit_24();
    }else{
       carry = 0.;
    }
 
    float_seed_table[i_lag] = uni;
    i_lag --;
    j_lag --;
    if(i_lag < 0) i_lag = 23;
    if(j_lag < 0) j_lag = 23;
 
    if( uni < mantissa_bit_12() ){
       uni += mantissa_bit_24() * float_seed_table[j_lag];
       if( uni == 0) uni = mantissa_bit_24() * mantissa_bit_24();
    }
    next_random = uni;
    vect[index] = (double)next_random;
    count24 ++;
 
// every 24th number generation, several random numbers are generated
// and wasted depending upon the luxury level.
 
    if(count24 == 24 ){
       count24 = 0;
       for( i = 0; i != nskip ; i++){
           uni = float_seed_table[j_lag] - float_seed_table[i_lag] - carry;
           if(uni < 0. ){
              uni += 1.0;
              carry = mantissa_bit_24();
           }else{
              carry = 0.;
           }
           float_seed_table[i_lag] = uni;
           i_lag --;
           j_lag --;
           if(i_lag < 0)i_lag = 23;
           if(j_lag < 0) j_lag = 23;
        }
    }
  }
} 

get() [1/2]

bool CLHEP::RanluxEngine::get ( const std::vector< unsigned long > &  v )

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 507 of file RanluxEngine.cc.

                                                          {
  if ((v[0] & 0xffffffffUL) != engineIDulong<RanluxEngine>()) {
    std::cerr << 
        "\nRanluxEngine get:state vector has wrong ID word - state unchanged\n";
    return false;
  }
  return getState(v);
}

get() [2/2]

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

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 444 of file RanluxEngine.cc.

{
  char beginMarker [MarkerLen];
  is >> std::ws;
  is.width(MarkerLen);  // causes the next read to the char* to be <=
            // that many bytes, INCLUDING A TERMINATION \0 
            // (Stroustrup, section 21.3.2)
  is >> beginMarker;
  if (strcmp(beginMarker,"RanluxEngine-begin")) {
     is.clear(std::ios::badbit | is.rdstate());
     std::cerr << "\nInput stream mispositioned or"
           << "\nRanluxEngine state description missing or"
           << "\nwrong engine type found." << std::endl;
     return is;
  }
  return getState(is);
}

getLuxury()

int CLHEP::RanluxEngine::getLuxury ( ) const

inline

Definition at line 91 of file RanluxEngine.h.

{ return luxury; }

getState() [1/2]

bool CLHEP::RanluxEngine::getState ( const std::vector< unsigned long > &  v )

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 516 of file RanluxEngine.cc.

                                                               {
  if (v.size() != VECTOR_STATE_SIZE ) {
    std::cerr << 
        "\nRanluxEngine get:state vector has wrong length - state unchanged\n";
    return false;
  }
  for (int i=0; i<24; ++i) {
    float_seed_table[i] = v[i+1]*mantissa_bit_24();
  }
  i_lag    = v[25];
  j_lag    = v[26];
  carry    = v[27]*mantissa_bit_24();
  count24  = v[28];
  luxury   = v[29];
  nskip    = v[30];
  return true;
}

getState() [2/2]

std::istream & CLHEP::RanluxEngine::getState ( std::istream &  is )

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 466 of file RanluxEngine.cc.

{
  if ( possibleKeywordInput ( is, "Uvec", theSeed ) ) {
    std::vector<unsigned long> v;
    unsigned long uu;
    for (unsigned int ivec=0; ivec < VECTOR_STATE_SIZE; ++ivec) {
      is >> uu;
      if (!is) {
        is.clear(std::ios::badbit | is.rdstate());
        std::cerr << "\nRanluxEngine state (vector) description improper."
        << "\ngetState() has failed."
           << "\nInput stream is probably mispositioned now." << std::endl;
        return is;
      }
      v.push_back(uu);
    }
    getState(v);
    return (is);
  }
 
//  is >> theSeed;  Removed, encompassed by possibleKeywordInput()
 
  char endMarker   [MarkerLen];
  for (int i=0; i<24; ++i) {
     is >> float_seed_table[i];
  }
  is >> i_lag; is >>  j_lag;
  is >> carry; is >> count24;
  is >> luxury; is >> nskip;
  is >> std::ws;
  is.width(MarkerLen);  
  is >> endMarker;
  if (strcmp(endMarker,"RanluxEngine-end")) {
     is.clear(std::ios::badbit | is.rdstate());
     std::cerr << "\nRanluxEngine state description incomplete."
           << "\nInput stream is probably mispositioned now." << std::endl;
     return is;
  }
  return is;
}

Referenced by get(), getState(), and restoreStatus().

name()

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

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 51 of file RanluxEngine.cc.

{return "RanluxEngine";}

operator unsigned int()

CLHEP::RanluxEngine::operator unsigned int ( )

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 410 of file RanluxEngine.cc.

                                    {
   return ((unsigned int)(flat() * exponent_bit_32()) & 0xffffffff) |
         (((unsigned int)(float_seed_table[i_lag]*exponent_bit_32())>>16) & 0xff);
   // needed because Ranlux doesn't fill all bits of the double
   // which therefore doesn't fill all bits of the integer.
}

put() [1/2]

std::vector< unsigned long > CLHEP::RanluxEngine::put ( ) const

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 428 of file RanluxEngine.cc.

                                                  {
  std::vector<unsigned long> v;
  v.push_back (engineIDulong<RanluxEngine>());
  for (int i=0; i<24; ++i) {
    v.push_back
        (static_cast<unsigned long>(float_seed_table[i]/mantissa_bit_24()));
  }
  v.push_back(static_cast<unsigned long>(i_lag));
  v.push_back(static_cast<unsigned long>(j_lag));
  v.push_back(static_cast<unsigned long>(carry/mantissa_bit_24()));
  v.push_back(static_cast<unsigned long>(count24));
  v.push_back(static_cast<unsigned long>(luxury));
  v.push_back(static_cast<unsigned long>(nskip));
  return v;
}

Referenced by put(), and saveStatus().

put() [2/2]

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

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 417 of file RanluxEngine.cc.

{
   char beginMarker[] = "RanluxEngine-begin";
  os << beginMarker << "\nUvec\n";
  std::vector<unsigned long> v = put();
  for (unsigned int i=0; i<v.size(); ++i) {
     os <<  v[i] <<  "\n";
  }
  return os;  
}

restoreStatus()

void CLHEP::RanluxEngine::restoreStatus ( const char  filename[] = "Ranlux.conf" )

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 257 of file RanluxEngine.cc.

{
   std::ifstream inFile( filename, std::ios::in);
   if (!checkFile ( inFile, filename, engineName(), "restoreStatus" )) {
     std::cerr << "  -- Engine state remains unchanged\n";
     return;
   }
  if ( possibleKeywordInput ( inFile, "Uvec", theSeed ) ) {
    std::vector<unsigned long> v;
    unsigned long xin;
    for (unsigned int ivec=0; ivec < VECTOR_STATE_SIZE; ++ivec) {
      inFile >> xin;
      if (!inFile) {
        inFile.clear(std::ios::badbit | inFile.rdstate());
        std::cerr << "\nRanluxEngine state (vector) description improper."
           << "\nrestoreStatus has failed."
           << "\nInput stream is probably mispositioned now." << std::endl;
        return;
      }
      v.push_back(xin);
    }
    getState(v);
    return;
  }
 
   if (!inFile.bad() && !inFile.eof()) {
//     inFile >> theSeed;  removed -- encompased by possibleKeywordInput
     for (int i=0; i<24; ++i)
       inFile >> float_seed_table[i];
     inFile >> i_lag; inFile >> j_lag;
     inFile >> carry; inFile >> count24;
     inFile >> luxury; inFile >> nskip;
   }
}

saveStatus()

void CLHEP::RanluxEngine::saveStatus ( const char  filename[] = "Ranlux.conf" ) const

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 245 of file RanluxEngine.cc.

{
   std::ofstream outFile( filename, std::ios::out ) ;
  if (!outFile.bad()) {
    outFile << "Uvec\n";
    std::vector<unsigned long> v = put();
    for (unsigned int i=0; i<v.size(); ++i) {
      outFile << v[i] << "\n";
    }
  }
}

setSeed()

void CLHEP::RanluxEngine::setSeed ( long  seed, int  lux = 3  )

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 123 of file RanluxEngine.cc.

                                             {
 
// The initialisation is carried out using a Multiplicative
// Congruential generator using formula constants of L'Ecuyer 
// as described in "A review of pseudorandom number generators"
// (Fred James) published in Computer Physics Communications 60 (1990)
// pages 329-344
 
  const int ecuyer_a = 53668;
  const int ecuyer_b = 40014;
  const int ecuyer_c = 12211;
  const int ecuyer_d = 2147483563;
 
  const int lux_levels[5] = {0,24,73,199,365};  
 
  long int_seed_table[24];
  long next_seed = seed;
  long k_multiple;
  int i;
  
// number of additional random numbers that need to be 'thrown away'
// every 24 numbers is set using luxury level variable.
 
  theSeed = seed;
  if( (lux > 4)||(lux < 0) ){
     if(lux >= 24){
        nskip = lux - 24;
     }else{
        nskip = lux_levels[3]; // corresponds to default luxury level
     }
  }else{
     luxury = lux;
     nskip = lux_levels[luxury];
  }
 
   
  for(i = 0;i != 24;i++){
     k_multiple = next_seed / ecuyer_a;
     next_seed = ecuyer_b * (next_seed - k_multiple * ecuyer_a) 
     - k_multiple * ecuyer_c ;
     if(next_seed < 0)next_seed += ecuyer_d;
     int_seed_table[i] = next_seed % int_modulus;
  }     
 
  for(i = 0;i != 24;i++)
    float_seed_table[i] = int_seed_table[i] * mantissa_bit_24();
 
  i_lag = 23;
  j_lag = 9;
  carry = 0. ;
 
  if( float_seed_table[23] == 0. ) carry = mantissa_bit_24();
  
  count24 = 0;
}

Referenced by RanluxEngine(), and setSeeds().

setSeeds()

void CLHEP::RanluxEngine::setSeeds ( const long *  seeds, int  lux = 3  )

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 179 of file RanluxEngine.cc.

                                                      {
 
   const int ecuyer_a = 53668;
   const int ecuyer_b = 40014;
   const int ecuyer_c = 12211;
   const int ecuyer_d = 2147483563;
 
   const int lux_levels[5] = {0,24,73,199,365};
   int i;
   long int_seed_table[24];
   long k_multiple,next_seed;
   const long *seedptr; 
 
   theSeeds = seeds;
   seedptr  = seeds;
 
   if(seeds == 0){
      setSeed(theSeed,lux);
      theSeeds = &theSeed;
      return;
   }
 
   theSeed = *seeds;
 
// number of additional random numbers that need to be 'thrown away'
// every 24 numbers is set using luxury level variable.
 
  if( (lux > 4)||(lux < 0) ){
     if(lux >= 24){
        nskip = lux - 24;
     }else{
        nskip = lux_levels[3]; // corresponds to default luxury level
     }
  }else{
     luxury = lux;
     nskip = lux_levels[luxury];
  }
      
  for( i = 0;(i != 24)&&(*seedptr != 0);i++){
      int_seed_table[i] = *seedptr % int_modulus;
      seedptr++;
  }            
 
  if(i != 24){
     next_seed = int_seed_table[i-1];
     for(;i != 24;i++){
        k_multiple = next_seed / ecuyer_a;
        next_seed = ecuyer_b * (next_seed - k_multiple * ecuyer_a) 
        - k_multiple * ecuyer_c ;
        if(next_seed < 0)next_seed += ecuyer_d;
        int_seed_table[i] = next_seed % int_modulus;
     }          
  }
 
  for(i = 0;i != 24;i++)
    float_seed_table[i] = int_seed_table[i] * mantissa_bit_24();
 
  i_lag = 23;
  j_lag = 9;
  carry = 0. ;
 
  if( float_seed_table[23] == 0. ) carry = mantissa_bit_24();
  
  count24 = 0;
}

Referenced by RanluxEngine().

showStatus()

void CLHEP::RanluxEngine::showStatus ( ) const

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 292 of file RanluxEngine.cc.

{
   std::cout << std::endl;
   std::cout << "--------- Ranlux engine status ---------" << std::endl;
   std::cout << " Initial seed = " << theSeed << std::endl;
   std::cout << " float_seed_table[] = ";
   for (int i=0; i<24; ++i)
     std::cout << float_seed_table[i] << " ";
   std::cout << std::endl;
   std::cout << " i_lag = " << i_lag << ", j_lag = " << j_lag << std::endl;
   std::cout << " carry = " << carry << ", count24 = " << count24 << std::endl;
   std::cout << " luxury = " << luxury << " nskip = " << nskip << std::endl;
   std::cout << "----------------------------------------" << std::endl;
}

Member Data Documentation

VECTOR_STATE_SIZE

const unsigned int CLHEP::RanluxEngine::VECTOR_STATE_SIZE = 31

static

Definition at line 108 of file RanluxEngine.h.

Referenced by getState(), and restoreStatus().

---

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

• RanluxEngine.h
• RanluxEngine.cc