[rand.req] - C++14 → C++17

Files changed (1) hide show

tmp/tmpbyuzopl_/{from.md → to.md} +29 -25

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

@@ -6,75 +6,78 @@ Throughout this subclause [[rand]], the effect of instantiating a
 template:
 Throughout this subclause [[rand]], phrases of the form “`x` is an
 iterator of a specific kind” shall be interpreted as equivalent to the
 more formal requirement that “`x` is a value of a type satisfying the
-requirements of the specified iterator type.”
 Throughout this subclause [[rand]], any constructor that can be called
 with a single argument and that satisfies a requirement specified in
 this subclause shall be declared `explicit`.
 #### Seed sequence requirements <a id="rand.req.seedseq">[[rand.req.seedseq]]</a>
 A *seed sequence* is an object that consumes a sequence of
 integer-valued data and produces a requested number of unsigned integer
-values i, 0 ≤ i < 2³², based on the consumed data. Such an object
-provides a mechanism to avoid replication of streams of random variates.
-This can be useful, for example, in applications requiring large numbers
-of random number engines.
 A class `S` satisfies the requirements of a seed sequence if the
 expressions shown in Table  [[tab:SeedSequence]] are valid and have the
 indicated semantics, and if `S` also satisfies all other requirements of
 this section [[rand.req.seedseq]]. In that Table and throughout this
 section:
-#### Uniform random number generator requirements <a id="rand.req.urng">[[rand.req.urng]]</a>
-A *uniform random number generator* `g` of type `G` is a function object
 returning unsigned integer values such that each value in the range of
-possible results has (ideally) equal probability of being returned. The
-degree to which `g`’s results approximate the ideal is often determined
-statistically.
-A class `G` satisfies the requirements of a *uniform random number
 generator* if the expressions shown in Table
-[[tab:UniformRandomNumberGenerator]] are valid and have the indicated
 semantics, and if `G` also satisfies all other requirements of this
 section [[rand.req.urng]]. In that Table and throughout this section:
 The following relation shall hold: `G::min() < G::max()`.
 #### Random number engine requirements <a id="rand.req.eng">[[rand.req.eng]]</a>
 A *random number engine* (commonly shortened to *engine*) `e` of type
-`E` is a uniform random number generator that additionally meets the
-requirements (*e.g.*, for seeding and for input/output) specified in
-this section.
 At any given time, `e` has a state eᵢ for some integer i ≥ 0. Upon
 construction, `e` has an initial state e₀. An engine’s state may be
 established via a constructor, a `seed` function, assignment, or a
 suitable `operator>>`.
 `E`’s specification shall define:
-A class `E` that satisfies the requirements of a uniform random number
 generator ([[rand.req.urng]]) also satisfies the requirements of a
 *random number engine* if the expressions shown in Table
 [[tab:RandomEngine]] are valid and have the indicated semantics, and if
 `E` also satisfies all other requirements of this section
 [[rand.req.eng]]. In that Table and throughout this section:
 where `charT` and `traits` are constrained according to Clause
 [[strings]] and Clause  [[input.output]].
 `E` shall meet the requirements of `CopyConstructible` (Table
-[[copyconstructible]]) and `CopyAssignable` (Table  [[copyassignable]])
-types. These operations shall each be of complexity no worse than
-𝑂(\mbox{size of state}).
 #### Random number engine adaptor requirements <a id="rand.req.adapt">[[rand.req.adapt]]</a>
 A *random number engine adaptor* (commonly shortened to *adaptor*) `a`
 of type `A` is a random number engine that takes values produced by some
@@ -106,11 +109,11 @@ A::A(result_type s);
 ```
 *Effects:* The base engine is initialized with `s`.
 ``` cpp
-template<class Sseq> void A::A(Sseq& q);
 ```
 *Effects:* The base engine is initialized with `q`.
 ``` cpp
@@ -158,12 +161,12 @@ In that Table and throughout this section,
 where `charT` and `traits` are constrained according to Clauses
 [[strings]] and [[input.output]].
 `D` shall satisfy the requirements of `CopyConstructible` (Table
-[[copyconstructible]]) and `CopyAssignable` (Table  [[copyassignable]])
-types.
 The sequence of numbers produced by repeated invocations of `d(g)` shall
 be independent of any invocation of `os << d` or of any `const` member
 function of `D` between any of the invocations `d(g)`.
@@ -177,12 +180,13 @@ It is unspecified whether `D::param_type` is declared as a (nested)
 `class` or via a `typedef`. In this subclause [[rand]], declarations of
 `D::param_type` are in the form of `typedef`s for convenience of
 exposition only.
 `P` shall satisfy the requirements of `CopyConstructible` (Table
-[[copyconstructible]]), `CopyAssignable` (Table  [[copyassignable]]),
-and `EqualityComparable` (Table  [[equalitycomparable]]) types.
 For each of the constructors of `D` taking arguments corresponding to
 parameters of the distribution, `P` shall have a corresponding
 constructor subject to the same requirements and taking arguments
 identical in number, type, and default values. Moreover, for each of the
@@ -191,8 +195,8 @@ of the distribution, `P` shall have a corresponding member function with
 the identical name, type, and semantics.
 `P` shall have a declaration of the form
 ``` cpp
-typedef  D  distribution_type;
 ```

 template:
 Throughout this subclause [[rand]], phrases of the form “`x` is an
 iterator of a specific kind” shall be interpreted as equivalent to the
 more formal requirement that “`x` is a value of a type satisfying the
+requirements of the specified iterator type”.
 Throughout this subclause [[rand]], any constructor that can be called
 with a single argument and that satisfies a requirement specified in
 this subclause shall be declared `explicit`.
 #### Seed sequence requirements <a id="rand.req.seedseq">[[rand.req.seedseq]]</a>
 A *seed sequence* is an object that consumes a sequence of
 integer-valued data and produces a requested number of unsigned integer
+values i, 0 ≤ i < 2³², based on the consumed data.
+[*Note 1*: Such an object provides a mechanism to avoid replication of
+streams of random variates. This can be useful, for example, in
+applications requiring large numbers of random number
+engines. — *end note*]
 A class `S` satisfies the requirements of a seed sequence if the
 expressions shown in Table  [[tab:SeedSequence]] are valid and have the
 indicated semantics, and if `S` also satisfies all other requirements of
 this section [[rand.req.seedseq]]. In that Table and throughout this
 section:
+#### Uniform random bit generator requirements <a id="rand.req.urng">[[rand.req.urng]]</a>
+A *uniform random bit generator* `g` of type `G` is a function object
 returning unsigned integer values such that each value in the range of
+possible results has (ideally) equal probability of being returned.
+[*Note 1*: The degree to which `g`’s results approximate the ideal is
+often determined statistically. — *end note*]
+A class `G` satisfies the requirements of a *uniform random bit
 generator* if the expressions shown in Table
+[[tab:UniformRandomBitGenerator]] are valid and have the indicated
 semantics, and if `G` also satisfies all other requirements of this
 section [[rand.req.urng]]. In that Table and throughout this section:
 The following relation shall hold: `G::min() < G::max()`.
 #### Random number engine requirements <a id="rand.req.eng">[[rand.req.eng]]</a>
 A *random number engine* (commonly shortened to *engine*) `e` of type
+`E` is a uniform random bit generator that additionally meets the
+requirements (e.g., for seeding and for input/output) specified in this
+section.
 At any given time, `e` has a state eᵢ for some integer i ≥ 0. Upon
 construction, `e` has an initial state e₀. An engine’s state may be
 established via a constructor, a `seed` function, assignment, or a
 suitable `operator>>`.
 `E`’s specification shall define:
+A class `E` that satisfies the requirements of a uniform random bit
 generator ([[rand.req.urng]]) also satisfies the requirements of a
 *random number engine* if the expressions shown in Table
 [[tab:RandomEngine]] are valid and have the indicated semantics, and if
 `E` also satisfies all other requirements of this section
 [[rand.req.eng]]. In that Table and throughout this section:
 where `charT` and `traits` are constrained according to Clause
 [[strings]] and Clause  [[input.output]].
 `E` shall meet the requirements of `CopyConstructible` (Table
+[[tab:copyconstructible]]) and `CopyAssignable` (Table
+[[tab:copyassignable]]) types. These operations shall each be of
+complexity no worse than 𝑂(\mbox{size of state}).
 #### Random number engine adaptor requirements <a id="rand.req.adapt">[[rand.req.adapt]]</a>
 A *random number engine adaptor* (commonly shortened to *adaptor*) `a`
 of type `A` is a random number engine that takes values produced by some
 ```
 *Effects:* The base engine is initialized with `s`.
 ``` cpp
+template<class Sseq> A::A(Sseq& q);
 ```
 *Effects:* The base engine is initialized with `q`.
 ``` cpp
 where `charT` and `traits` are constrained according to Clauses
 [[strings]] and [[input.output]].
 `D` shall satisfy the requirements of `CopyConstructible` (Table
+[[tab:copyconstructible]]) and `CopyAssignable` (Table
+[[tab:copyassignable]]) types.
 The sequence of numbers produced by repeated invocations of `d(g)` shall
 be independent of any invocation of `os << d` or of any `const` member
 function of `D` between any of the invocations `d(g)`.
 `class` or via a `typedef`. In this subclause [[rand]], declarations of
 `D::param_type` are in the form of `typedef`s for convenience of
 exposition only.
 `P` shall satisfy the requirements of `CopyConstructible` (Table
+[[tab:copyconstructible]]), `CopyAssignable` (Table
+[[tab:copyassignable]]), and `EqualityComparable` (Table
+[[tab:equalitycomparable]]) types.
 For each of the constructors of `D` taking arguments corresponding to
 parameters of the distribution, `P` shall have a corresponding
 constructor subject to the same requirements and taking arguments
 identical in number, type, and default values. Moreover, for each of the
 the identical name, type, and semantics.
 `P` shall have a declaration of the form
 ``` cpp
+using distribution_type =  D;
 ```

Diff to HTML by rtfpessoa