29 Numerics library [numerics]

An independent_­bits_­engine random number engine adaptor combines random numbers that are produced by some base engine e, so as to produce random numbers with a specified number of bits w. The state x${}_i$ of an independent_­bits_­engine engine adaptor object x consists of the state e${}_i$ of its base engine e; the size of the state is the size of e's state.

The transition and generation algorithms are described in terms of the following integral constants:

1. a)Let $R=\text{e.max() - e.min() + 1}$ and $m=\lfloor {\log }_{2}R\rfloor$.

2. b)With n as determined below, let $w_0=\lfloor w/n\rfloor$, $n_0=n-wmodn$, $y_0=2^{w_0}\lfloor R/2^{w_0}\rfloor$, and $y_1=2^{w_0+1}\lfloor R/2^{w_0+1}\rfloor$.

3. c)Let $n=\lceil w/m\rceil$ if and only if the relation $R-y_0\le \lfloor y_0/n\rfloor$ holds as a result. Otherwise let $n=1+\lceil w/m\rceil$.

[ Note: The relation $w=n_0{w}_0+(n-n_0)(w_0+1)$ always holds.  — end note ]

The transition algorithm is carried out by invoking e() as often as needed to obtain $n_0$ values less than $y_0+\text{e.min()}$ and $n-n_0$ values less than $y_1+\text{e.min()}$.

The generation algorithm uses the values produced while advancing the state as described above to yield a quantity S obtained as if by the following algorithm:

S = 0;
for (k = 0; $k\ne n_0$; k += 1)  {
 do u = e() - e.min(); while ($u\ge y_0$);
 S = $2^{w_0}\cdot S+umod{2}^{w_0}$;
}
for (k = $n_0$; $k\ne n$; k += 1)  {
 do u = e() - e.min(); while ($u\ge y_1$);
 S = $2^{w_0+1}\cdot S+umod{2}^{w_0+1}$;
}

template<class Engine, size_t w, class UIntType>
  class independent_bits_engine {
  public:
    // types
    using result_type = UIntType;

    // engine characteristics
    static constexpr result_type min() { return 0; }
    static constexpr result_type max() { return $2^w-1$; }

    // constructors and seeding functions
    independent_bits_engine();
    explicit independent_bits_engine(const Engine& e);
    explicit independent_bits_engine(Engine&& e);
    explicit independent_bits_engine(result_type s);
    template<class Sseq> explicit independent_bits_engine(Sseq& q);
    void seed();
    void seed(result_type s);
    template<class Sseq> void seed(Sseq& q);

    // generating functions
    result_type operator()();
    void discard(unsigned long long z);

    // property functions
    const Engine& base() const noexcept { return e; };

  private:
    Engine e;   // exposition only
  };

The following relations shall hold: 0 < w and w <= numeric_­limits<result_­type>​::​digits.

The textual representation consists of the textual representation of e.