#include <RanshiEngine.h>

Inheritance diagram for CLHEP::RanshiEngine:

Public Member Functions
	RanshiEngine ()

	RanshiEngine (std::istream &is)

	RanshiEngine (long seed)

	RanshiEngine (int rowIndex, int colIndex)

virtual	~RanshiEngine ()

double	flat ()

void	flatArray (const int size, double *vect)

void	setSeed (long seed, int)

void	setSeeds (const long *seeds, int)

void	saveStatus (const char filename[]="RanshiEngine.conf") const

void	restoreStatus (const char filename[]="RanshiEngine.conf")

void	showStatus () const

	operator float ()

	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)

long	getSeed () const

const long *	getSeeds () const

virtual	operator double ()

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)

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 52 of file RanshiEngine.h.

Constructor & Destructor Documentation

CLHEP::RanshiEngine::RanshiEngine ( )

Definition at line 48 of file RanshiEngine.cc.

References flat(), int(), and CLHEP::HepRandomEngine::theSeed.

Referenced by setSeed().

 : HepRandomEngine(),
   halfBuff(0), numFlats(0) 
 {
   int i = 0;
   while (i < numBuff) {    
     buffer[i] = (unsigned int)(numEngines+19780503L*(i+1));
     ++i;
   }
   theSeed = numEngines+19780503L*++i;
   redSpin = (unsigned int)(theSeed & 0xffffffff);
   ++numEngines;
   for( i = 0; i < 10000; ++i) flat();  // Warm-up by running thorugh 10000 nums
 }

CLHEP::RanshiEngine::RanshiEngine ( std::istream & is )

Definition at line 63 of file RanshiEngine.cc.

 : HepRandomEngine(),
   halfBuff(0), numFlats(0) 
 {
   is >> *this;
 }

CLHEP::RanshiEngine::RanshiEngine ( long seed )

Definition at line 70 of file RanshiEngine.cc.

References flat(), int(), and CLHEP::HepRandomEngine::theSeed.

 : HepRandomEngine(),
   halfBuff(0), numFlats(0) 
 {
   for (int i = 0; i < numBuff; ++i) {
     buffer[i] = (unsigned int)seed&0xffffffff;
   }
   theSeed = seed;
   redSpin = (unsigned int)(theSeed & 0xffffffff);
   int j;
   for (j = 0; j < numBuff*20; ++j) {      // "warm-up" for engine to hit
     flat();                               //  every ball on average 20X.
   }
 }

CLHEP::RanshiEngine::RanshiEngine	(	int	rowIndex,
		int	colIndex
	)

Definition at line 85 of file RanshiEngine.cc.

References flat(), int(), and CLHEP::HepRandomEngine::theSeed.

 : HepRandomEngine(),
   halfBuff(0), numFlats(0) 
 {
   int i = 0;
   while( i < numBuff ) {
     buffer[i] = (unsigned int)((rowIndex + (i+1)*(colIndex+8))&0xffffffff);
     ++i;
   }
   theSeed = rowIndex;
   redSpin = colIndex & 0xffffffff;
   for( i = 0; i < 100; ++i) flat();    // Warm-up by running thorugh 100 nums
 }

CLHEP::RanshiEngine::~RanshiEngine ( )

virtual

Definition at line 99 of file RanshiEngine.cc.

99 { }

Member Function Documentation

std::string CLHEP::RanshiEngine::beginTag ( )

static

Definition at line 267 of file RanshiEngine.cc.

                                     { 
   return "RanshiEngine-begin"; 
 }

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

inlinestatic

Definition at line 95 of file RanshiEngine.h.

Referenced by restoreStatus().

95 {return "RanshiEngine";}

double CLHEP::RanshiEngine::flat ( )

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 101 of file RanshiEngine.cc.

References CLHEP::HepRandomEngine::nearlyTwoToMinus_54(), CLHEP::HepRandomEngine::twoToMinus_32(), and CLHEP::HepRandomEngine::twoToMinus_53().

Referenced by flatArray(), and RanshiEngine().

                           {
   unsigned int redAngle = (((numBuff/2) - 1) & redSpin) + halfBuff;
   unsigned int blkSpin     = buffer[redAngle] & 0xffffffff;
   unsigned int boostResult = blkSpin ^ redSpin;
 
   buffer[redAngle] = ((blkSpin << 17) | (blkSpin >> (32-17))) ^ redSpin;
   
   redSpin  = (blkSpin + numFlats++) & 0xffffffff;
   halfBuff = numBuff/2 - halfBuff;
   
   return ( blkSpin * twoToMinus_32() +            // most significant part
        (boostResult>>11) * twoToMinus_53() +  // fill in remaining bits
        nearlyTwoToMinus_54());          // non-zero
 }

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

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 116 of file RanshiEngine.cc.

References flat().

                                                          {
   for (int i = 0; i < size; ++i) {
     vect[i] = flat();
   }
 }

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

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 250 of file RanshiEngine.cc.

References getState().

                                              {
   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,"RanshiEngine-begin")) {
     is.clear(std::ios::badbit | is.rdstate());
     std::cerr << "\nInput mispositioned or"
           << "\nRanshiEngine state description missing or"
           << "\nwrong engine type found." << std::endl;
     return is;
   }
   return getState(is);
 }

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

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 309 of file RanshiEngine.cc.

References getState().

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

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

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 271 of file RanshiEngine.cc.

References CLHEP::possibleKeywordInput(), CLHEP::HepRandomEngine::theSeed, and test::v.

Referenced by get(), and restoreStatus().

                                                   {
   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 << "\nRanshiEngine 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 < numBuff; ++i) {
     is >> buffer[i];
   }
   is >> redSpin >> numFlats >> halfBuff;
   is >> std::ws;
   is.width(MarkerLen);  
   is >> endMarker;
   if (strcmp(endMarker,"RanshiEngine-end")) {
     is.clear(std::ios::badbit | is.rdstate());
     std::cerr << "\nRanshiEngine state description incomplete."
           << "\nInput stream is probably mispositioned now." << std::endl;
     return is;
   }
   return is;
 }

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

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 318 of file RanshiEngine.cc.

                                                                {
   if (v.size() != VECTOR_STATE_SIZE ) {
     std::cerr << 
         "\nRanshiEngine get:state vector has wrong length - state unchanged\n";
     return false;
   }
   for (int i = 0; i < numBuff; ++i) {
     buffer[i] = v[i+1];
   }
   redSpin  = v[numBuff+1];
   numFlats = v[numBuff+2]; 
   halfBuff = v[numBuff+3];
   return true;
 }

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

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 43 of file RanshiEngine.cc.

43 {return "RanshiEngine";}

CLHEP::RanshiEngine::operator float ( )

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 204 of file RanshiEngine.cc.

References buffer.

                              {
   unsigned int redAngle = (((numBuff/2) - 1) & redSpin) + halfBuff;
   unsigned int blkSpin  = buffer[redAngle] & 0xffffffff;
   
   buffer[redAngle] = ((blkSpin << 17) | (blkSpin >> (32-17))) ^ redSpin;
   
   redSpin  = (blkSpin + numFlats++) & 0xffffffff;
   halfBuff = numBuff/2 - halfBuff;
   
   return float(blkSpin * twoToMinus_32());
 }

CLHEP::RanshiEngine::operator unsigned int ( )

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 216 of file RanshiEngine.cc.

References buffer.

                                     {
   unsigned int redAngle = (((numBuff/2) - 1) & redSpin) + halfBuff;
   unsigned int blkSpin  = buffer[redAngle] & 0xffffffff;
   
   buffer[redAngle] = ((blkSpin << 17) | (blkSpin >> (32-17))) ^ redSpin;
   
   redSpin  = (blkSpin + numFlats++) & 0xffffffff;
   halfBuff = numBuff/2 - halfBuff;
   
   return blkSpin;
 }

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

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 228 of file RanshiEngine.cc.

References put(), and test::v.

                                                     {
   char beginMarker[] = "RanshiEngine-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;  
 }

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

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 238 of file RanshiEngine.cc.

References test::v.

Referenced by put(), and saveStatus().

                                                   {
   std::vector<unsigned long> v;
   v.push_back (engineIDulong<RanshiEngine>());
   for (int i = 0; i < numBuff; ++i) {
     v.push_back(static_cast<unsigned long>(buffer[i]));
   }
   v.push_back(static_cast<unsigned long>(redSpin));
   v.push_back(static_cast<unsigned long>(numFlats));
   v.push_back(static_cast<unsigned long>(halfBuff));  
   return v;
 }

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

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 154 of file RanshiEngine.cc.

References CLHEP::HepRandomEngine::checkFile(), engineName(), getState(), CLHEP::possibleKeywordInput(), CLHEP::HepRandomEngine::theSeed, and test::v.

                                                       {
   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 << "\nRanshiEngine 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 >> theSeed;  removed -- encompased by possibleKeywordInput
     for (int i = 0; i < numBuff; ++i) {
       inFile >> buffer[i];
     }
     inFile >> redSpin >> numFlats >> halfBuff;
   }
 }

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

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 143 of file RanshiEngine.cc.

References outFile, put(), and test::v.

                                                          {
   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";
     }
   }
 }

void CLHEP::RanshiEngine::setSeed	(	long	seed,
		int
	)

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 122 of file RanshiEngine.cc.

References RanshiEngine().

                                          {
   *this = RanshiEngine(seed); 
 }

void CLHEP::RanshiEngine::setSeeds	(	const long *	seeds,
		int
	)

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 126 of file RanshiEngine.cc.

References int(), CLHEP::HepRandomEngine::theSeed, and CLHEP::HepRandomEngine::theSeeds.

                                                   {
   if (*seeds) {
     int i = 0;
     while (seeds[i] && i < numBuff) {
       buffer[i] = (unsigned int)seeds[i];
       ++i;
     }
     while (i < numBuff) {
       buffer[i] = buffer[i-1];
       ++i;
     }
     theSeed = seeds[0];
     redSpin = (unsigned int)theSeed;
   }
   theSeeds = seeds;
 }

void CLHEP::RanshiEngine::showStatus ( ) const

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 187 of file RanshiEngine.cc.

References right, and CLHEP::HepRandomEngine::theSeed.

                                     {
   std::cout << std::setprecision(20) << std::endl;
   std::cout << "----------- Ranshi engine status ----------" << std::endl;
   std::cout << "Initial seed      = " << theSeed << std::endl;
   std::cout << "Current red spin  = " << redSpin << std::endl;
   std::cout << "Values produced   = " << numFlats << std::endl;
   std::cout << "Side of buffer    = " << (halfBuff ? "upper" : "lower")
         << std::endl;
   std::cout << "Current buffer    = " << std::endl;
   for (int i = 0; i < numBuff; i+=4) {
     std::cout << std::setw(10) << std::setiosflags(std::ios::right)
           << buffer[i]     << std::setw(11) << buffer[i+1] << std::setw(11)
           << buffer[i+2]   << std::setw(11) << buffer[i+3] << std::endl;
   }
   std::cout << "-------------------------------------------" << std::endl;
 }

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

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation