[rand.adapt] - C++17 → C++20

Files changed (1) hide show

tmp/tmp2n3jsd9x/{from.md → to.md} +29 -17

tmp/tmp2n3jsd9x/{from.md → to.md} RENAMED Viewed

@@ -1,33 +1,33 @@
 ### Random number engine adaptor class templates <a id="rand.adapt">[[rand.adapt]]</a>
 #### In general <a id="rand.adapt.general">[[rand.adapt.general]]</a>
-Each type instantiated from a class template specified in this section
-[[rand.adapt]] satisfies the requirements of a random number engine
-adaptor ([[rand.req.adapt]]) type.
 Except where specified otherwise, the complexity of each function
-specified in this section  [[rand.adapt]] is constant.
-Except where specified otherwise, no function described in this section
-[[rand.adapt]] throws an exception.
-Every function described in this section  [[rand.adapt]] that has a
 function parameter `q` of type `Sseq&` for a template type parameter
 named `Sseq` that is different from type `seed_seq` throws what and when
 the invocation of `q.generate` throws.
-Descriptions are provided in this section  [[rand.adapt]] only for
-adaptor operations that are not described in section  [[rand.req.adapt]]
-or for operations where there is additional semantic information. In
-particular, declarations for copy constructors, for copy assignment
-operators, for streaming operators, and for equality and inequality
-operators are not shown in the synopses.
-Each template specified in this section  [[rand.adapt]] requires one or
-more relationships, involving the value(s) of its non-type template
 parameter(s), to hold. A program instantiating any of these templates is
 ill-formed if any such required relationship fails to hold.
 #### Class template `discard_block_engine` <a id="rand.adapt.disc">[[rand.adapt.disc]]</a>
@@ -85,11 +85,11 @@ template<class Engine, size_t p, size_t r>
 The following relations shall hold: `0 < r` and `r <= p`.
 The textual representation consists of the textual representation of `e`
 followed by the value of `n`.
-In addition to its behavior pursuant to section  [[rand.req.adapt]],
 each constructor that is not a copy constructor sets `n` to 0.
 #### Class template `independent_bits_engine` <a id="rand.adapt.ibits">[[rand.adapt.ibits]]</a>
 An `independent_bits_engine` random number engine adaptor combines
@@ -100,10 +100,17 @@ state eᵢ 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:
 [*Note 1*: The relation w = n₀ w₀ + (n - n₀)(w₀ + 1) always
 holds. — *end note*]
 The transition algorithm is carried out by invoking `e()` as often as
 needed to obtain n₀ values less than y₀ + `e.min()` and n - n₀ values
@@ -175,10 +182,15 @@ additional sequence V of k values also of the type delivered by `e`. The
 size of the state is the size of e’s state plus k + 1.
 The transition algorithm permutes the values produced by e. The state
 transition is performed as follows:
 The generation algorithm yields the last value of `Y` produced while
 advancing `e`’s state as described above.
 ``` cpp
 template<class Engine, size_t k>
@@ -219,10 +231,10 @@ template<class Engine, size_t k>
 The following relation shall hold: `0 < k`.
 The textual representation consists of the textual representation of
 `e`, followed by the `k` values of V, followed by the value of Y.
-In addition to its behavior pursuant to section  [[rand.req.adapt]],
 each constructor that is not a copy constructor initializes
 `V[0]`, …, `V[k-1]` and Y, in that order, with values returned by
 successive invocations of `e()`.

 ### Random number engine adaptor class templates <a id="rand.adapt">[[rand.adapt]]</a>
 #### In general <a id="rand.adapt.general">[[rand.adapt.general]]</a>
+Each type instantiated from a class template specified in this
+subclause  [[rand.adapt]] meets the requirements of a random number
+engine adaptor [[rand.req.adapt]] type.
 Except where specified otherwise, the complexity of each function
+specified in this subclause  [[rand.adapt]] is constant.
+Except where specified otherwise, no function described in this
+subclause  [[rand.adapt]] throws an exception.
+Every function described in this subclause  [[rand.adapt]] that has a
 function parameter `q` of type `Sseq&` for a template type parameter
 named `Sseq` that is different from type `seed_seq` throws what and when
 the invocation of `q.generate` throws.
+Descriptions are provided in this subclause  [[rand.adapt]] only for
+adaptor operations that are not described in subclause
+[[rand.req.adapt]] or for operations where there is additional semantic
+information. In particular, declarations for copy constructors, for copy
+assignment operators, for streaming operators, and for equality and
+inequality operators are not shown in the synopses.
+Each template specified in this subclause  [[rand.adapt]] requires one
+or more relationships, involving the value(s) of its non-type template
 parameter(s), to hold. A program instantiating any of these templates is
 ill-formed if any such required relationship fails to hold.
 #### Class template `discard_block_engine` <a id="rand.adapt.disc">[[rand.adapt.disc]]</a>
 The following relations shall hold: `0 < r` and `r <= p`.
 The textual representation consists of the textual representation of `e`
 followed by the value of `n`.
+In addition to its behavior pursuant to subclause  [[rand.req.adapt]],
 each constructor that is not a copy constructor sets `n` to 0.
 #### Class template `independent_bits_engine` <a id="rand.adapt.ibits">[[rand.adapt.ibits]]</a>
 An `independent_bits_engine` random number engine adaptor combines
 e’s state.
 The transition and generation algorithms are described in terms of the
 following integral constants:
+- Let R = `e.max() - e.min() + 1` and m = ⌊ log₂ R ⌋.
+- With n as determined below, let w₀ = ⌊ w / n ⌋, n₀ = n - w  mod  n,
+  $y_0 = 2^{w_0} \left\lfloor R / 2^{w_0} \right\rfloor$, and
+  $y_1 = 2^{w_0 + 1} \left\lfloor R / 2^{w_0 + 1} \right\rfloor$.
+- Let n = ⌈ w / m ⌉ if and only if the relation R - y₀ ≤ ⌊ y₀ / n ⌋
+  holds as a result. Otherwise let n = 1 + ⌈ w / m ⌉.
 [*Note 1*: The relation w = n₀ w₀ + (n - n₀)(w₀ + 1) always
 holds. — *end note*]
 The transition algorithm is carried out by invoking `e()` as often as
 needed to obtain n₀ values less than y₀ + `e.min()` and n - n₀ values
 size of the state is the size of e’s state plus k + 1.
 The transition algorithm permutes the values produced by e. The state
 transition is performed as follows:
+- Calculate an integer $j = \left\lfloor \frac{k \cdot (Y - e_{\min})}
+                            {e_{\max} - e_{\min} +1}
+          \right\rfloor$ .
+- Set Y to Vⱼ and then set Vⱼ to `e()`.
 The generation algorithm yields the last value of `Y` produced while
 advancing `e`’s state as described above.
 ``` cpp
 template<class Engine, size_t k>
 The following relation shall hold: `0 < k`.
 The textual representation consists of the textual representation of
 `e`, followed by the `k` values of V, followed by the value of Y.
+In addition to its behavior pursuant to subclause  [[rand.req.adapt]],
 each constructor that is not a copy constructor initializes
 `V[0]`, …, `V[k-1]` and Y, in that order, with values returned by
 successive invocations of `e()`.

Diff to HTML by rtfpessoa