## RanshiEngine |

The algorithm for this random engine was taken from *"F.Gutbrod, Comp.
Phys. Comm. 87 (1995) 291-306"*.

The algorithm can be imagined as a physical system as follows: Imagine 512 "black balls" each with their own unique spin, and positions characterized by disrete angles, where the spin is a 32-bit unsigned integer. A "red ball" collides based upon the angle determined by the last 8 bits of its spin, and the spin of the colliding ball is taken as the output random number. The spin of the colliding ball is replaced then with the left circular shift of the black ball's spin XOR'd with the red ball's spin. The black ball's old spin becomes the red ball's.

To avoid the traps presented, two measures are taken: first, the red ball will oscillate between hitting the lower half of the buffer on one turn and the upper half on another; second, the red ball's spin is incremented by a counter of the number of random numbers produced.

The result is scaled to a double precision floating point number to which
is added another random double further scaled *2^(53-32)* places to the
right in order to ensure that the remaining bits of the result are not
left empty due to the mere 32 bits representation used internally.

Engines: HepRandomEngine, DRand48Engine , DualRand, HepJamesRandom, Hurd160Engine, Hurd288Engine, MTwistEngine, RandEngine, RanecuEngine, RanluxEngine, Ranlux64Engine, TripleRand

Distributions: HepRandom, RandBinomial, RandBit, RandBreitWigner, RandChiSquare, RandExponential, RandFlat, RandGamma, RandGauss, RandGaussQ, RandGaussT, RandGeneral, RandLandau, RandPoisson, RandPoissonQ, RandPoissonT, RandStudentT

Functions: HepStat

#include "CLHEP/Random/RanshiEngine.h" class RanshiEngine: public HepRandomEngine

**Constructors**`RanshiEngine()``RanshiEngine(long seed)``RanshiEngine(HepInt rowIndex, HepInt colIndex)``RanshiEngine(HepStd::istream& is)`**Copy constructor**`RanshiEngine(const RanshiEngine & p)`**Destructor**`virtual ~RanshiEngine()`**Conversion operators**`operator HepFloat()`- Flat value, without worrying about filling bits
`operator unsigned int()`- 32-bit flat value, quickest of all
**=**`RanshiEngine & operator=(const RanshiEngine & p)`- Assignment
**flat**`HepDouble flat()`- Returns a pseudo random number between
*0*and*1* **flatArray**`void flatArray(const HepInt size, HepDouble* vect)`- Fills an array
`vect`of specified size with flat random values. **restoreStatus**`void restoreStatus(const char filename[] = "RanshiEngine.conf")`- Reads from named file the last saved engine status and restores it.
**saveStatus**`void saveStatus(const char filename[] = "RanshiEngine.conf") const`- Saves on named file the current engine status.
**setSeed**`void setSeed(long seed, HepInt)`- Sets the state of the algorithm according to seed.
**setSeeds**`void setSeeds(const long * seeds, HepInt)`- Sets the state of the algorithm according to the zero-terminated array of seeds.
**showStatus**`void showStatus() const`- Dumps the current engine status on the screen.

**<<**`HepStd::ostream & operator<< (HepStd::ostream & os, const RanshiEngine & e)`- Output to a stream.
**>>**`HepStd::istream & operator>> (HepStd::istream & is, RanshiEngine & e)`- Input from a stream.

EVC