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

Files changed (1) hide show

tmp/tmppsk2vzj0/{from.md → to.md} +134 -44

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

@@ -3,18 +3,39 @@
 #### General requirements <a id="rand.req.genl">[[rand.req.genl]]</a>
 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
@@ -23,61 +44,105 @@ 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
@@ -132,11 +197,20 @@ void seed(result_type s);
 template<class Sseq> void seed(Sseq& q);
 ```
 *Effects:* With `b` as the base engine, invokes `b.seed(q)`.
-`A` shall also satisfy the following additional requirements:
 #### Random number distribution requirements <a id="rand.req.dist">[[rand.req.dist]]</a>
 A *random number distribution* (commonly shortened to *distribution*)
 `d` of type `D` is a function object returning values that are
@@ -151,22 +225,38 @@ distribution*. Such distribution parameters are identified in this
 context by writing, for example, p(z | a,b) or P(zᵢ | a,b), to name
 specific parameters, or by writing, for example, p(z |{`p`}) or
 P(zᵢ |{`p`}), to denote a distribution’s parameters `p` taken as a
 whole.
-A class `D` satisfies the requirements of a *random number distribution*
-if the expressions shown in Table  [[tab:RandomDistribution]] are valid
-and have the indicated semantics, and if `D` and its associated types
-also satisfy all other requirements of this section [[rand.req.dist]].
-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
-[[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)`.
@@ -179,14 +269,14 @@ produce the same sequence of numbers as would repeated invocations of
 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
-[[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

 #### General requirements <a id="rand.req.genl">[[rand.req.genl]]</a>
 Throughout this subclause [[rand]], the effect of instantiating a
 template:
+- that has a template type parameter named `Sseq` is undefined unless
+  the corresponding template argument is cv-unqualified and meets the
+  requirements of seed sequence [[rand.req.seedseq]].
+- that has a template type parameter named `URBG` is undefined unless
+  the corresponding template argument is cv-unqualified and meets the
+  requirements of uniform random bit generator [[rand.req.urng]].
+- that has a template type parameter named `Engine` is undefined unless
+  the corresponding template argument is cv-unqualified and meets the
+  requirements of random number engine [[rand.req.eng]].
+- that has a template type parameter named `RealType` is undefined
+  unless the corresponding template argument is cv-unqualified and is
+  one of `float`, `double`, or `long double`.
+- that has a template type parameter named `IntType` is undefined unless
+  the corresponding template argument is cv-unqualified and is one of
+  `short`, `int`, `long`, `long long`, `unsigned short`, `unsigned int`,
+  `unsigned long`, or `unsigned long long`.
+- that has a template type parameter named `UIntType` is undefined
+  unless the corresponding template argument is cv-unqualified and is
+  one of `unsigned short`, `unsigned int`, `unsigned long`, or
+  `unsigned long long`.
 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 meeting the
 requirements of the specified iterator type”.
 Throughout this subclause [[rand]], any constructor that can be called
+with a single argument and that meets 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
 [*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` meets the requirements of a seed sequence if the expressions
+shown in [[rand.req.seedseq]] are valid and have the indicated
+semantics, and if `S` also meets all other requirements of this
+subclause [[rand.req.seedseq]]. In that Table and throughout this
+subclause:
+- `T` is the type named by `S`’s associated `result_type`;
+- `q` is a value of `S` and `r` is a possibly const value of `S`;
+- `ib` and `ie` are input iterators with an unsigned integer
+  `value_type` of at least 32 bits;
+- `rb` and `re` are mutable random access iterators with an unsigned
+  integer `value_type` of at least 32 bits;
+- `ob` is an output iterator; and
+- `il` is a value of `initializer_list<T>`.
 #### 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*]
+``` cpp
+template<class G>
+  concept uniform_random_bit_generator =
+    invocable<G&> && unsigned_integral<invoke_result_t<G&>> &&
+    requires {
+      { G::min() } -> same_as<invoke_result_t<G&>>;
+      { G::max() } -> same_as<invoke_result_t<G&>>;
+      requires bool_constant<(G::min() < G::max())>::value;
+    };
+```
+Let `g` be an object of type `G`. `G` models
+`uniform_random_bit_generator` only if
+- `G::min() <= g()`,
+- `g() <= G::max()`, and
+- `g()` has amortized constant complexity.
+A class `G` meets the *uniform random bit generator* requirements if `G`
+models `uniform_random_bit_generator`, `invoke_result_t<G&>` is an
+unsigned integer type [[basic.fundamental]], and `G` provides a nested
+*typedef-name* `result_type` that denotes the same type as
+`invoke_result_t<G&>`.
 #### 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
+subclause.
 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:
+- the size of `E`’s state in multiples of the size of `result_type`,
+  given as an integral constant expression;
+- the *transition algorithm* TA by which `e`’s state eᵢ is advanced to
+  its *successor state* eᵢ₊₁; and
+- the *generation algorithm* GA by which an engine’s state is mapped to
+  a value of type `result_type`.
+A class `E` that meets the requirements of a uniform random bit
+generator [[rand.req.urng]] also meets the requirements of a *random
+number engine* if the expressions shown in [[rand.req.eng]] are valid
+and have the indicated semantics, and if `E` also meets all other
+requirements of this subclause [[rand.req.eng]]. In that Table and
+throughout this subclause:
+- `T` is the type named by `E`’s associated `result_type`;
+- `e` is a value of `E`, `v` is an lvalue of `E`, `x` and `y` are
+  (possibly `const`) values of `E`;
+- `s` is a value of `T`;
+- `q` is an lvalue meeting the requirements of a seed sequence
+  [[rand.req.seedseq]];
+- `z` is a value of type `unsigned long long`;
+- `os` is an lvalue of the type of some class template specialization
+  `basic_ostream<charT,` `traits>`; and
+- `is` is an lvalue of the type of some class template specialization
+  `basic_istream<charT,` `traits>`;
+where `charT` and `traits` are constrained according to [[strings]] and
+[[input.output]].
+`E` shall meet the *Cpp17CopyConstructible* (
+[[cpp17.copyconstructible]]) and *Cpp17CopyAssignable* (
+[[cpp17.copyassignable]]) requirements. These operations shall each be
+of complexity no worse than 𝑂(\text{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
 template<class Sseq> void seed(Sseq& q);
 ```
 *Effects:* With `b` as the base engine, invokes `b.seed(q)`.
+`A` shall also meet the following additional requirements:
+- The complexity of each function shall not exceed the complexity of the
+  corresponding function applied to the base engine.
+- The state of `A` shall include the state of its base engine. The size
+  of `A`’s state shall be no less than the size of the base engine.
+- Copying `A`’s state (e.g., during copy construction or copy
+  assignment) shall include copying the state of the base engine of `A`.
+- The textual representation of `A` shall include the textual
+  representation of its base engine.
 #### Random number distribution requirements <a id="rand.req.dist">[[rand.req.dist]]</a>
 A *random number distribution* (commonly shortened to *distribution*)
 `d` of type `D` is a function object returning values that are
 context by writing, for example, p(z | a,b) or P(zᵢ | a,b), to name
 specific parameters, or by writing, for example, p(z |{`p`}) or
 P(zᵢ |{`p`}), to denote a distribution’s parameters `p` taken as a
 whole.
+A class `D` meets the requirements of a *random number distribution* if
+the expressions shown in [[rand.req.dist]] are valid and have the
+indicated semantics, and if `D` and its associated types also meet all
+other requirements of this subclause [[rand.req.dist]]. In that Table
+and throughout this subclause,
+- `T` is the type named by `D`’s associated `result_type`;
+- `P` is the type named by `D`’s associated `param_type`;
+- `d` is a value of `D`, and `x` and `y` are (possibly `const`) values
+  of `D`;
+- `glb` and `lub` are values of `T` respectively corresponding to the
+  greatest lower bound and the least upper bound on the values
+  potentially returned by `d`’s `operator()`, as determined by the
+  current values of `d`’s parameters;
+- `p` is a (possibly `const`) value of `P`;
+- `g`, `g1`, and `g2` are lvalues of a type meeting the requirements of
+  a uniform random bit generator [[rand.req.urng]];
+- `os` is an lvalue of the type of some class template specialization
+  `basic_ostream<charT,` `traits>`; and
+- `is` is an lvalue of the type of some class template specialization
+  `basic_istream<charT,` `traits>`;
+where `charT` and `traits` are constrained according to [[strings]] and
+[[input.output]].
+`D` shall meet the *Cpp17CopyConstructible* (
+[[cpp17.copyconstructible]]) and *Cpp17CopyAssignable* (
+[[cpp17.copyassignable]]) requirements.
 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)`.
 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 meet the *Cpp17CopyConstructible* (
+[[cpp17.copyconstructible]]), *Cpp17CopyAssignable* (
+[[cpp17.copyassignable]]), and *Cpp17EqualityComparable* (
+[[cpp17.equalitycomparable]]) requirements.
 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

Diff to HTML by rtfpessoa