[rand.adapt.ibits]

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

(2.1)
Let $R = e.max() - e.min() + 1 and m=⌊log2R⌋.$
(2.2)
With n as determined below, let
(2.3)
Let $n = ⌈ w / m ⌉ if and only if the relation R - {y 0 \leq ⌊ {y 0 / n ⌋ holds as a result .}_{0 / n ⌋ holds as a result .}}_{0 \leq ⌊ {y 0 / n ⌋ holds as a result .}_{0 / n ⌋ holds as a result .}}$

Otherwise let $n = 1 + ⌈ w / m ⌉ .$

[Note 1:

The relation

w = {n 0 {w 0 + (n - {n 0) ({w 0 + 1) always holds .}_{0 + 1) always holds .}}_{0) ({w 0 + 1) always holds .}_{0 + 1) always holds .}}}_{0 + (n - {n 0) ({w 0 + 1) always holds .}_{0 + 1) always holds .}}_{0) ({w 0 + 1) always holds .}_{0 + 1) always holds .}}}}_{0 {w 0 + (n - {n 0) ({w 0 + 1) always holds .}_{0 + 1) always holds .}}_{0) ({w 0 + 1) always holds .}_{0 + 1) always holds .}}}_{0 + (n - {n 0) ({w 0 + 1) always holds .}_{0 + 1) always holds .}}_{0) ({w 0 + 1) always holds .}_{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 + e.min() and n - {n 0 values less than {y 1 + e.min() .}_{1 + e.min() .}}_{0 values less than {y 1 + e.min() .}_{1 + e.min() .}}}_{0 + e.min() and n - {n 0 values less than {y 1 + e.min() .}_{1 + e.min() .}}_{0 values less than {y 1 + e.min() .}_{1 + e.min() .}}}}_{0 values less than {y 0 + e.min() and n - {n 0 values less than {y 1 + e.min() .}_{1 + e.min() .}}_{0 values less than {y 1 + e.min() .}_{1 + e.min() .}}}_{0 + e.min() and n - {n 0 values less than {y 1 + e.min() .}_{1 + e.min() .}}_{0 values less than {y 1 + e.min() .}_{1 + 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;

🔗

namespace std { 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

2w−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); / equality operators friend bool operator=(const independent_bits_engine& x, const independent_bits_engine& y); / generating functions result_type operator()(); void discard(unsigned long z); / property functions const Engine& base() const noexcept { return e; } / inserters and extractors template<class charT, class traits> friend basic_ostream<charT, traits>& operator<(basic_ostream<charT, traits>& os, const independent_bits_engine& x); / hosted template<class charT, class traits> friend basic_istream<charT, traits>& operator>(basic_istream<charT, traits>& is, independent_bits_engine& x); / hosted 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.