Public Member Functions
void	get (std::istream &is)

bool	get (std::vector< unsigned long >::const_iterator &iv)

	operator unsigned int ()

void	put (std::ostream &os) const

void	put (std::vector< unsigned long > &v) const

	Tausworthe ()

	Tausworthe (unsigned int seed)

Private Attributes
int	wordIndex

unsigned int	words [4]

Detailed Description

Definition at line 108 of file DualRand.h.

Constructor & Destructor Documentation

◆ Tausworthe() [1/2]

CLHEP::DualRand::Tausworthe::Tausworthe ( )

Definition at line 315 of file DualRand.cc.

                               {
  words[0] = 1234567;
  for (wordIndex = 1; wordIndex < 4; ++wordIndex) {
    words[wordIndex] = 69607 * words[wordIndex-1] + 54329;
  } 
}

References wordIndex, and words.

◆ Tausworthe() [2/2]

CLHEP::DualRand::Tausworthe::Tausworthe ( unsigned int seed )

Definition at line 322 of file DualRand.cc.

                                                {
  words[0] = seed;
  for (wordIndex = 1; wordIndex < 4; ++wordIndex) {
    words[wordIndex] = 69607 * words[wordIndex-1] + 54329;
  }
}

Member Function Documentation

◆ get() [1/2]

void CLHEP::DualRand::Tausworthe::get ( std::istream & is )

Definition at line 408 of file DualRand.cc.

                                            {
  char beginMarker [MarkerLen];
  char endMarker   [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,"Tausworthe-begin")) {
    is.clear(std::ios::badbit | is.rdstate());
    std::cerr << "\nInput mispositioned or"
          << "\nTausworthe state description missing or"
          << "\nwrong engine type found." << std::endl;
  }
  for (int i = 0; i < 4; ++i) {
    is >> words[i];
  }
  is >> wordIndex;
  is >> std::ws;
  is.width(MarkerLen);  
  is >> endMarker;
  if (strcmp(endMarker,"Tausworthe-end")) {
    is.clear(std::ios::badbit | is.rdstate());
    std::cerr << "\nTausworthe state description incomplete."
          << "\nInput stream is probably mispositioned now." << std::endl;
  }
}

References CLHEP::MarkerLen.

Referenced by CLHEP::DualRand::getState(), and CLHEP::DualRand::restoreStatus().

◆ get() [2/2]

bool CLHEP::DualRand::Tausworthe::get ( std::vector< unsigned long >::const_iterator & iv )

Definition at line 438 of file DualRand.cc.

                                                                  {
  for (int i = 0; i < 4; ++i) {
    words[i] = *iv++;
  }
  wordIndex = *iv++;
  return true;
}

◆ operator unsigned int()

CLHEP::DualRand::Tausworthe::operator unsigned int ( )

Definition at line 329 of file DualRand.cc.

                                          {
 
// Mathematically:  Consider a sequence of bits b[n].  Repeatedly form
// b[0]' = b[127] ^ b[97]; b[n]' = b[n-1].  This sequence will have a very
// long period (2**127-1 according to Tausworthe's work).
 
// The actual method used relies on the fact that the operations needed to
// form bit 0 for up to 96 iterations never depend on the results of the
// previous ones.  So you can actually compute many bits at once.  In fact
// you can compute 32 at once -- despite 127 - 97 < 32 -- but 24 was used in
// the method used in Canopy, where they wanted only single-precision float
// randoms.  I will do 32 here.
 
// When you do it this way, this looks disturbingly like the dread lagged XOR
// Fibonacci.  And indeed, it is a lagged Fibonacii, F(4,3, op) with the op
// being the XOR of a combination of shifts of the two numbers.  Although
// Tausworthe asserted excellent properties, I would be scared to death.
// However, the shifting and bit swapping really does randomize this in a
// serious way.
 
// Statements have been made to the effect that shift register sequences fail
// the parking lot test because they achieve randomness by multiple foldings,
// and this produces a characteristic pattern.  We observe that in this
// specific algorithm, which has a fairly long lever arm, the foldings become
// effectively random.  This is evidenced by the fact that the generator
// does pass the Diehard tests, including the parking lot test.
 
// To avoid shuffling of variables in memory, you either have to use circular
// pointers (and those give you ifs, which are also costly) or compute at least
// a few iterations at once.  We do the latter.  Although there is a possible
// trade of room for more speed, by computing and saving 256 instead of 128
// bits at once, I will stop at this level of optimization.
 
// To remind:  Each (32-bit) step takes the XOR of bits [127-96] with bits
// [95-64] and places it in bits [0-31].  But in the first step, we designate
// word0 as bits [0-31], in the second step, word 1 (since the bits it holds
// will no longer be needed), then word 2, then word 3.  After this, the
// stream contains 128 random bits which we will use as 4 valid 32-bit
// random numbers.
 
// Thus at the start of the first step, word[0] contains the newest (used)
// 32-bit random, and word[3] the oldest.   After four steps, word[0] again
// contains the newest (now unused) random, and word[3] the oldest.
// Bit 0 of word[0] is logically the newest bit, and bit 31 of word[3]
// the oldest.
 
  if (wordIndex <= 0) {
    for (wordIndex = 0; wordIndex < 4; ++wordIndex) {
      words[wordIndex] = ( (words[(wordIndex+1) & 3] << 1 ) |
                                   (words[wordIndex] >> 31)   )
                       ^ ( (words[(wordIndex+1) & 3] << 31) |
                                   (words[wordIndex] >>  1)   );
    }
  }
  return words[--wordIndex] & 0xffffffff;
}

◆ put() [1/2]

void CLHEP::DualRand::Tausworthe::put ( std::ostream & os ) const

Definition at line 386 of file DualRand.cc.

                                                  {
  char beginMarker[] = "Tausworthe-begin";
  char endMarker[]   = "Tausworthe-end";
 
  int pr=os.precision(20);
  os << " " << beginMarker << " ";
  for (int i = 0; i < 4; ++i) {
    os << words[i] << " ";
  }
  os << wordIndex;
  os << " " <<  endMarker  << " ";
  os << std::endl;
  os.precision(pr);
}

Referenced by CLHEP::DualRand::put(), and CLHEP::DualRand::showStatus().

◆ put() [2/2]

void CLHEP::DualRand::Tausworthe::put ( std::vector< unsigned long > & v ) const

Definition at line 401 of file DualRand.cc.

                                                               {
  for (int i = 0; i < 4; ++i) {
    v.push_back(static_cast<unsigned long>(words[i]));
  }
  v.push_back(static_cast<unsigned long>(wordIndex)); 
}

Field Documentation

◆ wordIndex

int CLHEP::DualRand::Tausworthe::wordIndex

private

Definition at line 118 of file DualRand.h.

Referenced by Tausworthe().

◆ words

unsigned int CLHEP::DualRand::Tausworthe::words[4]