| Home | Libraries | People | FAQ | More

## 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.