Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

PrevUpHomeNext

Class template discard_block_engine

boost::random::discard_block_engine

Synopsis

// In header: <boost/random/discard_block.hpp>

template<typename UniformRandomNumberGenerator, std::size_t p, std::size_t r> 
class discard_block_engine {
public:
  // types
  typedef UniformRandomNumberGenerator base_type;  
  typedef base_type::result_type       result_type;

  // construct/copy/destruct
  discard_block_engine();
  explicit discard_block_engine(const base_type &);
  explicit discard_block_engine(base_type &&);
  explicit discard_block_engine(seed_type);
  template<typename SeedSeq> explicit discard_block_engine(SeedSeq &);
  template<typename It> discard_block_engine(It &, It);

  // public member functions
  void seed();
  void seed(seed_type);
  template<typename SeedSeq> void seed(SeedSeq &);
  template<typename It> void seed(It &, It);
  const base_type & base() const;
  result_type operator()();
  void discard(boost::uintmax_t);
  template<typename It> void generate(It, It);

  // public static functions
  static result_type min();
  static result_type max();

  // friend functions
  template<typename CharT, typename Traits> 
    friend std::basic_ostream< CharT, Traits > & 
    operator<<(std::basic_ostream< CharT, Traits > &, 
               const discard_block_engine &);
  template<typename CharT, typename Traits> 
    friend std::basic_istream< CharT, Traits > & 
    operator>>(std::basic_istream< CharT, Traits > &, discard_block_engine &);
  friend bool operator==(const discard_block_engine &, 
                         const discard_block_engine &);
  friend bool operator!=(const discard_block_engine &, 
                         const discard_block_engine &);

  // public data members
  static const std::size_t block_size;
  static const std::size_t used_block;
  static const bool has_fixed_range;
  static const std::size_t total_block;
  static const std::size_t returned_block;
};

Description

The class template discard_block_engine is a model of pseudo-random number generator . It modifies another generator by discarding parts of its output. Out of every block of p results, the first r will be returned and the rest discarded.

Requires: 0 < p <= r

discard_block_engine public construct/copy/destruct

  1. discard_block_engine();

    Uses the default seed for the base generator.

  2. explicit discard_block_engine(const base_type & rng);

    Constructs a new discard_block_engine with a copy of rng.

  3. explicit discard_block_engine(base_type && rng);

    Constructs a new discard_block_engine with rng.

  4. explicit discard_block_engine(seed_type value);

    Creates a new discard_block_engine and seeds the underlying generator with value

  5. template<typename SeedSeq> explicit discard_block_engine(SeedSeq & seq);

    Creates a new discard_block_engine and seeds the underlying generator with seq

  6. template<typename It> discard_block_engine(It & first, It last);

    Creates a new discard_block_engine and seeds the underlying generator with first and last.

discard_block_engine public member functions

  1. void seed();

    default seeds the underlying generator.

  2. void seed(seed_type s);

    Seeds the underlying generator with s.

  3. template<typename SeedSeq> void seed(SeedSeq & seq);

    Seeds the underlying generator with seq.

  4. template<typename It> void seed(It & first, It last);

    Seeds the underlying generator with first and last.

  5. const base_type & base() const;

    Returns the underlying engine.

  6. result_type operator()();

    Returns the next value of the generator.

  7. void discard(boost::uintmax_t z);
  8. template<typename It> void generate(It first, It last);

discard_block_engine public static functions

  1. static result_type min();

    Returns the smallest value that the generator can produce. This is the same as the minimum of the underlying generator.

  2. static result_type max();

    Returns the largest value that the generator can produce. This is the same as the maximum of the underlying generator.

discard_block_engine friend functions

  1. template<typename CharT, typename Traits> 
      friend std::basic_ostream< CharT, Traits > & 
      operator<<(std::basic_ostream< CharT, Traits > & os, 
                 const discard_block_engine & s);

    Writes a discard_block_engine to a std::ostream.

  2. template<typename CharT, typename Traits> 
      friend std::basic_istream< CharT, Traits > & 
      operator>>(std::basic_istream< CharT, Traits > & is, 
                 discard_block_engine & s);

    Reads a discard_block_engine from a std::istream.

  3. friend bool operator==(const discard_block_engine & x, 
                           const discard_block_engine & y);

    Returns true if the two generators will produce identical sequences.

  4. friend bool operator!=(const discard_block_engine & x, 
                           const discard_block_engine & y);

    Returns true if the two generators will produce different sequences.


PrevUpHomeNext