[rand.adapt] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpn_qy9c6o/{from.md → to.md} +27 -25

tmp/tmpn_qy9c6o/{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
-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>
@@ -50,11 +50,11 @@ invocation of `e()` while advancing `e`’s state as described above.
 namespace std {
   template<class Engine, size_t p, size_t r>
   class discard_block_engine {
   public:
     // types
-    using result_type = typename Engine::result_type;
     // engine characteristics
     static constexpr size_t block_size = p;
     static constexpr size_t used_block = r;
     static constexpr result_type min() { return Engine::min(); }
@@ -81,14 +81,14 @@ namespace std {
     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 discard_block_engine& x);
     template<class charT, class traits>
       friend basic_istream<charT, traits>&
-        operator>>(basic_istream<charT, traits>& is, discard_block_engine& x);
   private:
     Engine e;   // exposition only
     size_t n;   // exposition only
   };
@@ -144,10 +144,11 @@ for (k = n₀; k \neq n; k += 1)  {
  S = 2^{w₀ + 1} \cdot S + u \bmod 2^{w₀ + 1};
 }
 ```
 ``` cpp
   template<class Engine, size_t w, class UIntType>
   class independent_bits_engine {
   public:
     // types
     using result_type = UIntType;
@@ -177,18 +178,19 @@ template<class Engine, size_t w, class UIntType>
     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);
     template<class charT, class traits>
       friend basic_istream<charT, traits>&
-        operator>>(basic_istream<charT, traits>& is, independent_bits_engine& x);
   private:
     Engine e;   // exposition only
   };
 ```
 The following relations shall hold: `0 < w` and
 `w <= numeric_limits<result_type>::digits`.
@@ -220,11 +222,11 @@ advancing `e`’s state as described above.
 namespace std {
   template<class Engine, size_t k>
   class shuffle_order_engine {
   public:
     // types
-    using result_type = typename Engine::result_type;
     // engine characteristics
     static constexpr size_t table_size = k;
     static constexpr result_type min() { return Engine::min(); }
     static constexpr result_type max() { return Engine::max(); }

 ### Random number engine adaptor class templates <a id="rand.adapt">[[rand.adapt]]</a>
+#### General <a id="rand.adapt.general">[[rand.adapt.general]]</a>
+Each type instantiated from a class template specified in [[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 [[rand.adapt]] is constant.
+Except where specified otherwise, no function described in
+[[rand.adapt]] throws an exception.
+Every function described in [[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 [[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 [[rand.adapt]] requires one or more
+relationships, involving the value(s) of its constant 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>
 namespace std {
   template<class Engine, size_t p, size_t r>
   class discard_block_engine {
   public:
     // types
+    using result_type = Engine::result_type;
     // engine characteristics
     static constexpr size_t block_size = p;
     static constexpr size_t used_block = r;
     static constexpr result_type min() { return Engine::min(); }
     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 discard_block_engine& x);    // hosted
     template<class charT, class traits>
       friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is, discard_block_engine& x);          // hosted
   private:
     Engine e;   // exposition only
     size_t n;   // exposition only
   };
  S = 2^{w₀ + 1} \cdot S + u \bmod 2^{w₀ + 1};
 }
 ```
 ``` cpp
+namespace std {
   template<class Engine, size_t w, class UIntType>
   class independent_bits_engine {
   public:
     // types
     using result_type = UIntType;
     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`.
 namespace std {
   template<class Engine, size_t k>
   class shuffle_order_engine {
   public:
     // types
+    using result_type = Engine::result_type;
     // engine characteristics
     static constexpr size_t table_size = k;
     static constexpr result_type min() { return Engine::min(); }
     static constexpr result_type max() { return Engine::max(); }

Diff to HTML by rtfpessoa