RanluxppEngine.h

Go to the documentation of this file.

//
// -*- C++ -*-
//
// -----------------------------------------------------------------------
//                             HEP Random
//                       --- RanluxppEngine ---
//                         class header file
// -----------------------------------------------------------------------
// Implementation of the RANLUX++ generator
//
// RANLUX++ is an LCG equivalent of RANLUX using 576 bit numbers.
//
// References:
// A. Sibidanov
//   A revision of the subtract-with-borrow random numbergenerators
//   Computer Physics Communications, 221(2017), 299-303
//
// J. Hahnfeld, L. Moneta
//   A Portable Implementation of RANLUX++
//   vCHEP2021
 
#ifndef RanluxppEngine_h
#define RanluxppEngine_h
 
#include "CLHEP/Random/RandomEngine.h"
 
#include <cstdint>
 
namespace CLHEP {
 
/**
 * @author Jonas Hahnfeld
 * @ingroup random
 */
class RanluxppEngine final : public HepRandomEngine {
 
public:
  RanluxppEngine();
  RanluxppEngine(long seed);
  RanluxppEngine(std::istream &is);
  virtual ~RanluxppEngine();
  // Constructors and destructor
 
  double flat() override;
  // It returns a pseudo random number between 0 and 1,
  // excluding the end points.
 
  void flatArray(const int size, double *vect) override;
  // Fills the array "vect" of specified size with flat random values.
 
  void setSeed(long seed, int dummy = 0) override;
  // Sets the state of the algorithm according to seed.
 
  void setSeeds(const long *seeds, int dummy = 0) override;
  // Sets the state of the algorithm according to the zero terminated
  // array of seeds.  Only the first seed is used.
 
  void skip(uint64_t n);
  // Skip `n` random numbers without generating them.
 
  void saveStatus(const char filename[] = "Ranluxpp.conf") const override;
  // Saves in named file the current engine status.
 
  void restoreStatus(const char filename[] = "Ranluxpp.conf") override;
  // Reads from named file the last saved engine status and restores it.
 
  void showStatus() const override;
  // Dumps the engine status on the screen.
 
  std::string name() const override;
 
  // Optional methods to serialize the engine's state into vectors and streams.
  static std::string engineName();
  static std::string beginTag();
 
  std::ostream &put(std::ostream &os) const override;
  std::istream &get(std::istream &is) override;
 
  std::istream &getState(std::istream &is) override;
 
  std::vector<unsigned long> put() const override;
  bool get(const std::vector<unsigned long> &v) override;
  bool getState(const std::vector<unsigned long> &v) override;
 
  // Save and restore to/from streams
  operator double() override { return flat(); }
  operator float() override { return float(flat()); }
  operator unsigned int() override { return (unsigned int)nextRandomBits(); }
 
  // 1 value for the engine ID, 2 * 9 values for the state, and 2 more values
  // for the carry bit and the position.
  static const unsigned int VECTOR_STATE_SIZE = 21;
 
private:
  void advance();
  uint64_t nextRandomBits();
 
  uint64_t fState[9]; ///< RANLUX state of the generator
  unsigned fCarry;    ///< Carry bit of the RANLUX state
  int fPosition = 0;  ///< Current position in bits
 
}; // RanluxppEngine
 
} // namespace CLHEP
 
#endif