From Jason Turner

[numbers]

C++20 → C++23 12.6 KB 114 lines
Current Draft | LaTeX Source
Archived: C++20 | C++23
Markdown: C++20 | C++23
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmp71csy1qj/{from.md → to.md} +51 -52
tmp/tmp71csy1qj/{from.md → to.md} RENAMED
@@ -2,37 +2,37 @@
2
 
3
  ### Header `<numbers>` synopsis <a id="numbers.syn">[[numbers.syn]]</a>
4
 
5
  ``` cpp
6
  namespace std::numbers {
7
- template<class T> inline constexpr T e_v = unspecified;
8
- template<class T> inline constexpr T log2e_v = unspecified;
9
- template<class T> inline constexpr T log10e_v = unspecified;
10
- template<class T> inline constexpr T pi_v = unspecified;
11
- template<class T> inline constexpr T inv_pi_v = unspecified;
12
- template<class T> inline constexpr T inv_sqrtpi_v = unspecified;
13
- template<class T> inline constexpr T ln2_v = unspecified;
14
- template<class T> inline constexpr T ln10_v = unspecified;
15
- template<class T> inline constexpr T sqrt2_v = unspecified;
16
- template<class T> inline constexpr T sqrt3_v = unspecified;
17
- template<class T> inline constexpr T inv_sqrt3_v = unspecified;
18
- template<class T> inline constexpr T egamma_v = unspecified;
19
- template<class T> inline constexpr T phi_v = unspecified;
20
 
21
- template<floating_point T> inline constexpr T e_v<T> = see below;
22
- template<floating_point T> inline constexpr T log2e_v<T> = see below;
23
- template<floating_point T> inline constexpr T log10e_v<T> = see below;
24
- template<floating_point T> inline constexpr T pi_v<T> = see below;
25
- template<floating_point T> inline constexpr T inv_pi_v<T> = see below;
26
- template<floating_point T> inline constexpr T inv_sqrtpi_v<T> = see below;
27
- template<floating_point T> inline constexpr T ln2_v<T> = see below;
28
- template<floating_point T> inline constexpr T ln10_v<T> = see below;
29
- template<floating_point T> inline constexpr T sqrt2_v<T> = see below;
30
- template<floating_point T> inline constexpr T sqrt3_v<T> = see below;
31
- template<floating_point T> inline constexpr T inv_sqrt3_v<T> = see below;
32
- template<floating_point T> inline constexpr T egamma_v<T> = see below;
33
- template<floating_point T> inline constexpr T phi_v<T> = see below;
34
 
35
  inline constexpr double e = e_v<double>;
36
  inline constexpr double log2e = log2e_v<double>;
37
  inline constexpr double log10e = log10e_v<double>;
38
  inline constexpr double pi = pi_v<double>;
@@ -66,27 +66,19 @@ constant variable template is ill-formed.
66
 
67
  <!-- Link reference definitions -->
68
  [bad.alloc]: support.md#bad.alloc
69
  [basic.fundamental]: basic.md#basic.fundamental
70
  [basic.stc.thread]: basic.md#basic.stc.thread
71
- [basic.types]: basic.md#basic.types
72
- [bit]: #bit
73
- [bit.cast]: #bit.cast
74
- [bit.count]: #bit.count
75
- [bit.endian]: #bit.endian
76
- [bit.general]: #bit.general
77
- [bit.pow.two]: #bit.pow.two
78
- [bit.rotate]: #bit.rotate
79
- [bit.syn]: #bit.syn
80
  [c.math]: #c.math
81
  [c.math.abs]: #c.math.abs
82
  [c.math.fpclass]: #c.math.fpclass
83
  [c.math.hypot3]: #c.math.hypot3
84
  [c.math.lerp]: #c.math.lerp
85
  [c.math.rand]: #c.math.rand
86
  [cfenv]: #cfenv
87
  [cfenv.syn]: #cfenv.syn
 
88
  [class.gslice]: #class.gslice
89
  [class.gslice.overview]: #class.gslice.overview
90
  [class.slice]: #class.slice
91
  [class.slice.overview]: #class.slice.overview
92
  [cmath.syn]: #cmath.syn
@@ -94,23 +86,22 @@ constant variable template is ill-formed.
94
  [complex]: #complex
95
  [complex.literals]: #complex.literals
96
  [complex.member.ops]: #complex.member.ops
97
  [complex.members]: #complex.members
98
  [complex.numbers]: #complex.numbers
 
99
  [complex.ops]: #complex.ops
100
- [complex.special]: #complex.special
101
  [complex.syn]: #complex.syn
102
  [complex.transcendentals]: #complex.transcendentals
103
  [complex.value.ops]: #complex.value.ops
104
  [cons.slice]: #cons.slice
105
  [conv.prom]: expr.md#conv.prom
106
  [cpp.pragma]: cpp.md#cpp.pragma
107
  [cpp17.copyassignable]: #cpp17.copyassignable
108
  [cpp17.copyconstructible]: #cpp17.copyconstructible
109
  [cpp17.equalitycomparable]: #cpp17.equalitycomparable
110
  [dcl.init]: dcl.md#dcl.init
111
- [expr.const]: expr.md#expr.const
112
  [gslice.access]: #gslice.access
113
  [gslice.array.assign]: #gslice.array.assign
114
  [gslice.array.comp.assign]: #gslice.array.comp.assign
115
  [gslice.array.fill]: #gslice.array.fill
116
  [gslice.cons]: #gslice.cons
@@ -118,11 +109,10 @@ constant variable template is ill-formed.
118
  [indirect.array.assign]: #indirect.array.assign
119
  [indirect.array.comp.assign]: #indirect.array.comp.assign
120
  [indirect.array.fill]: #indirect.array.fill
121
  [input.iterators]: iterators.md#input.iterators
122
  [input.output]: input.md#input.output
123
- [intro.object]: basic.md#intro.object
124
  [iostate.flags]: input.md#iostate.flags
125
  [istream.formatted]: input.md#istream.formatted
126
  [iterator.concept.contiguous]: iterators.md#iterator.concept.contiguous
127
  [iterator.requirements.general]: iterators.md#iterator.requirements.general
128
  [library.c]: library.md#library.c
@@ -137,10 +127,11 @@ constant variable template is ill-formed.
137
  [numeric.requirements]: #numeric.requirements
138
  [numerics]: #numerics
139
  [numerics.general]: #numerics.general
140
  [numerics.summary]: #numerics.summary
141
  [output.iterators]: iterators.md#output.iterators
 
142
  [rand]: #rand
143
  [rand.adapt]: #rand.adapt
144
  [rand.adapt.disc]: #rand.adapt.disc
145
  [rand.adapt.general]: #rand.adapt.general
146
  [rand.adapt.ibits]: #rand.adapt.ibits
@@ -172,13 +163,15 @@ constant variable template is ill-formed.
172
  [rand.dist.samp.plinear]: #rand.dist.samp.plinear
173
  [rand.dist.uni]: #rand.dist.uni
174
  [rand.dist.uni.int]: #rand.dist.uni.int
175
  [rand.dist.uni.real]: #rand.dist.uni.real
176
  [rand.eng]: #rand.eng
 
177
  [rand.eng.lcong]: #rand.eng.lcong
178
  [rand.eng.mers]: #rand.eng.mers
179
  [rand.eng.sub]: #rand.eng.sub
 
180
  [rand.predef]: #rand.predef
181
  [rand.req]: #rand.req
182
  [rand.req.adapt]: #rand.req.adapt
183
  [rand.req.dist]: #rand.req.dist
184
  [rand.req.eng]: #rand.req.eng
@@ -204,10 +197,11 @@ constant variable template is ill-formed.
204
  [sf.cmath.cyl.neumann]: #sf.cmath.cyl.neumann
205
  [sf.cmath.ellint.1]: #sf.cmath.ellint.1
206
  [sf.cmath.ellint.2]: #sf.cmath.ellint.2
207
  [sf.cmath.ellint.3]: #sf.cmath.ellint.3
208
  [sf.cmath.expint]: #sf.cmath.expint
 
209
  [sf.cmath.hermite]: #sf.cmath.hermite
210
  [sf.cmath.laguerre]: #sf.cmath.laguerre
211
  [sf.cmath.legendre]: #sf.cmath.legendre
212
  [sf.cmath.riemann.zeta]: #sf.cmath.riemann.zeta
213
  [sf.cmath.sph.bessel]: #sf.cmath.sph.bessel
@@ -227,10 +221,11 @@ constant variable template is ill-formed.
227
  [template.mask.array.overview]: #template.mask.array.overview
228
  [template.slice.array]: #template.slice.array
229
  [template.slice.array.overview]: #template.slice.array.overview
230
  [template.valarray]: #template.valarray
231
  [template.valarray.overview]: #template.valarray.overview
 
232
  [thread.jthread.class]: thread.md#thread.jthread.class
233
  [thread.thread.class]: thread.md#thread.thread.class
234
  [utility.arg.requirements]: library.md#utility.arg.requirements
235
  [valarray.access]: #valarray.access
236
  [valarray.assign]: #valarray.assign
@@ -249,57 +244,61 @@ constant variable template is ill-formed.
249
 
250
  [^1]: In other words, value types. These include arithmetic types,
251
  pointers, the library class `complex`, and instantiations of
252
  `valarray` for value types.
253
 
254
- [^2]: The name of this engine refers, in part, to a property of its
 
 
 
 
255
  period: For properly-selected values of the parameters, the period
256
  is closely related to a large Mersenne prime number.
257
 
258
- [^3]: The parameter is intended to allow an implementation to
259
  differentiate between different sources of randomness.
260
 
261
- [^4]: If a device has n states whose respective probabilities are
262
  P₀, …, Pₙ₋₁, the device entropy S is defined as
263
  $S = - \sum_{i=0}^{n-1} P_i \cdot \log P_i$.
264
 
265
- [^5]: b is introduced to avoid any attempt to produce more bits of
266
  randomness than can be held in `RealType`.
267
 
268
- [^6]: The distribution corresponding to this probability density
269
  function is also known (with a possible change of variable) as the
270
  Gumbel Type I, the log-Weibull, or the Fisher-Tippett Type I
271
  distribution.
272
 
273
- [^7]: [[implimits]] recommends a minimum number of recursively nested
274
  template instantiations. This requirement thus indirectly suggests a
275
  minimum allowable complexity for valarray expressions.
276
 
277
- [^8]: The intent is to specify an array template that has the minimum
278
  functionality necessary to address aliasing ambiguities and the
279
  proliferation of temporary objects. Thus, the `valarray` template is
280
  neither a matrix class nor a field class. However, it is a very
281
  useful building block for designing such classes.
282
 
283
- [^9]: This default constructor is essential, since arrays of `valarray`
284
- may be useful. After initialization, the length of an empty array
285
  can be increased with the `resize` member function.
286
 
287
- [^10]: This constructor is the preferred method for converting a C array
288
  to a `valarray` object.
289
 
290
- [^11]: This copy constructor creates a distinct array rather than an
291
  alias. Implementations in which arrays share storage are permitted,
292
  but they would need to implement a copy-on-reference mechanism to
293
  ensure that arrays are conceptually distinct.
294
 
295
- [^12]: BLAS stands for *Basic Linear Algebra Subprograms.* C++ programs
296
- may instantiate this class. See, for example, Dongarra, Du Croz,
297
  Duff, and Hammerling: *A set of Level 3 Basic Linear Algebra
298
  Subprograms*; Technical Report MCS-P1-0888, Argonne National
299
  Laboratory (USA), Mathematics and Computer Science Division, August,
300
  1988.
301
 
302
- [^13]: A mathematical function is mathematically defined for a given set
303
  of argument values (a) if it is explicitly defined for that set of
304
  argument values, or (b) if its limiting value exists and does not
305
  depend on the direction of approach.
 
2
 
3
  ### Header `<numbers>` synopsis <a id="numbers.syn">[[numbers.syn]]</a>
4
 
5
  ``` cpp
6
  namespace std::numbers {
7
+ template<class T> constexpr T e_v = unspecified;
8
+ template<class T> constexpr T log2e_v = unspecified;
9
+ template<class T> constexpr T log10e_v = unspecified;
10
+ template<class T> constexpr T pi_v = unspecified;
11
+ template<class T> constexpr T inv_pi_v = unspecified;
12
+ template<class T> constexpr T inv_sqrtpi_v = unspecified;
13
+ template<class T> constexpr T ln2_v = unspecified;
14
+ template<class T> constexpr T ln10_v = unspecified;
15
+ template<class T> constexpr T sqrt2_v = unspecified;
16
+ template<class T> constexpr T sqrt3_v = unspecified;
17
+ template<class T> constexpr T inv_sqrt3_v = unspecified;
18
+ template<class T> constexpr T egamma_v = unspecified;
19
+ template<class T> constexpr T phi_v = unspecified;
20
 
21
+ template<floating_point T> constexpr T e_v<T> = see below;
22
+ template<floating_point T> constexpr T log2e_v<T> = see below;
23
+ template<floating_point T> constexpr T log10e_v<T> = see below;
24
+ template<floating_point T> constexpr T pi_v<T> = see below;
25
+ template<floating_point T> constexpr T inv_pi_v<T> = see below;
26
+ template<floating_point T> constexpr T inv_sqrtpi_v<T> = see below;
27
+ template<floating_point T> constexpr T ln2_v<T> = see below;
28
+ template<floating_point T> constexpr T ln10_v<T> = see below;
29
+ template<floating_point T> constexpr T sqrt2_v<T> = see below;
30
+ template<floating_point T> constexpr T sqrt3_v<T> = see below;
31
+ template<floating_point T> constexpr T inv_sqrt3_v<T> = see below;
32
+ template<floating_point T> constexpr T egamma_v<T> = see below;
33
+ template<floating_point T> constexpr T phi_v<T> = see below;
34
 
35
  inline constexpr double e = e_v<double>;
36
  inline constexpr double log2e = log2e_v<double>;
37
  inline constexpr double log10e = log10e_v<double>;
38
  inline constexpr double pi = pi_v<double>;
 
66
 
67
  <!-- Link reference definitions -->
68
  [bad.alloc]: support.md#bad.alloc
69
  [basic.fundamental]: basic.md#basic.fundamental
70
  [basic.stc.thread]: basic.md#basic.stc.thread
 
 
 
 
 
 
 
 
 
71
  [c.math]: #c.math
72
  [c.math.abs]: #c.math.abs
73
  [c.math.fpclass]: #c.math.fpclass
74
  [c.math.hypot3]: #c.math.hypot3
75
  [c.math.lerp]: #c.math.lerp
76
  [c.math.rand]: #c.math.rand
77
  [cfenv]: #cfenv
78
  [cfenv.syn]: #cfenv.syn
79
+ [cfenv.thread]: #cfenv.thread
80
  [class.gslice]: #class.gslice
81
  [class.gslice.overview]: #class.gslice.overview
82
  [class.slice]: #class.slice
83
  [class.slice.overview]: #class.slice.overview
84
  [cmath.syn]: #cmath.syn
 
86
  [complex]: #complex
87
  [complex.literals]: #complex.literals
88
  [complex.member.ops]: #complex.member.ops
89
  [complex.members]: #complex.members
90
  [complex.numbers]: #complex.numbers
91
+ [complex.numbers.general]: #complex.numbers.general
92
  [complex.ops]: #complex.ops
 
93
  [complex.syn]: #complex.syn
94
  [complex.transcendentals]: #complex.transcendentals
95
  [complex.value.ops]: #complex.value.ops
96
  [cons.slice]: #cons.slice
97
  [conv.prom]: expr.md#conv.prom
98
  [cpp.pragma]: cpp.md#cpp.pragma
99
  [cpp17.copyassignable]: #cpp17.copyassignable
100
  [cpp17.copyconstructible]: #cpp17.copyconstructible
101
  [cpp17.equalitycomparable]: #cpp17.equalitycomparable
102
  [dcl.init]: dcl.md#dcl.init
 
103
  [gslice.access]: #gslice.access
104
  [gslice.array.assign]: #gslice.array.assign
105
  [gslice.array.comp.assign]: #gslice.array.comp.assign
106
  [gslice.array.fill]: #gslice.array.fill
107
  [gslice.cons]: #gslice.cons
 
109
  [indirect.array.assign]: #indirect.array.assign
110
  [indirect.array.comp.assign]: #indirect.array.comp.assign
111
  [indirect.array.fill]: #indirect.array.fill
112
  [input.iterators]: iterators.md#input.iterators
113
  [input.output]: input.md#input.output
 
114
  [iostate.flags]: input.md#iostate.flags
115
  [istream.formatted]: input.md#istream.formatted
116
  [iterator.concept.contiguous]: iterators.md#iterator.concept.contiguous
117
  [iterator.requirements.general]: iterators.md#iterator.requirements.general
118
  [library.c]: library.md#library.c
 
127
  [numeric.requirements]: #numeric.requirements
128
  [numerics]: #numerics
129
  [numerics.general]: #numerics.general
130
  [numerics.summary]: #numerics.summary
131
  [output.iterators]: iterators.md#output.iterators
132
+ [over.match.general]: over.md#over.match.general
133
  [rand]: #rand
134
  [rand.adapt]: #rand.adapt
135
  [rand.adapt.disc]: #rand.adapt.disc
136
  [rand.adapt.general]: #rand.adapt.general
137
  [rand.adapt.ibits]: #rand.adapt.ibits
 
163
  [rand.dist.samp.plinear]: #rand.dist.samp.plinear
164
  [rand.dist.uni]: #rand.dist.uni
165
  [rand.dist.uni.int]: #rand.dist.uni.int
166
  [rand.dist.uni.real]: #rand.dist.uni.real
167
  [rand.eng]: #rand.eng
168
+ [rand.eng.general]: #rand.eng.general
169
  [rand.eng.lcong]: #rand.eng.lcong
170
  [rand.eng.mers]: #rand.eng.mers
171
  [rand.eng.sub]: #rand.eng.sub
172
+ [rand.general]: #rand.general
173
  [rand.predef]: #rand.predef
174
  [rand.req]: #rand.req
175
  [rand.req.adapt]: #rand.req.adapt
176
  [rand.req.dist]: #rand.req.dist
177
  [rand.req.eng]: #rand.req.eng
 
197
  [sf.cmath.cyl.neumann]: #sf.cmath.cyl.neumann
198
  [sf.cmath.ellint.1]: #sf.cmath.ellint.1
199
  [sf.cmath.ellint.2]: #sf.cmath.ellint.2
200
  [sf.cmath.ellint.3]: #sf.cmath.ellint.3
201
  [sf.cmath.expint]: #sf.cmath.expint
202
+ [sf.cmath.general]: #sf.cmath.general
203
  [sf.cmath.hermite]: #sf.cmath.hermite
204
  [sf.cmath.laguerre]: #sf.cmath.laguerre
205
  [sf.cmath.legendre]: #sf.cmath.legendre
206
  [sf.cmath.riemann.zeta]: #sf.cmath.riemann.zeta
207
  [sf.cmath.sph.bessel]: #sf.cmath.sph.bessel
 
221
  [template.mask.array.overview]: #template.mask.array.overview
222
  [template.slice.array]: #template.slice.array
223
  [template.slice.array.overview]: #template.slice.array.overview
224
  [template.valarray]: #template.valarray
225
  [template.valarray.overview]: #template.valarray.overview
226
+ [term.literal.type]: basic.md#term.literal.type
227
  [thread.jthread.class]: thread.md#thread.jthread.class
228
  [thread.thread.class]: thread.md#thread.thread.class
229
  [utility.arg.requirements]: library.md#utility.arg.requirements
230
  [valarray.access]: #valarray.access
231
  [valarray.assign]: #valarray.assign
 
244
 
245
  [^1]: In other words, value types. These include arithmetic types,
246
  pointers, the library class `complex`, and instantiations of
247
  `valarray` for value types.
248
 
249
+ [^2]: This constructor (as well as the subsequent corresponding `seed()`
250
+ function) can be particularly useful to applications requiring a
251
+ large number of independent random sequences.
252
+
253
+ [^3]: The name of this engine refers, in part, to a property of its
254
  period: For properly-selected values of the parameters, the period
255
  is closely related to a large Mersenne prime number.
256
 
257
+ [^4]: The parameter is intended to allow an implementation to
258
  differentiate between different sources of randomness.
259
 
260
+ [^5]: If a device has n states whose respective probabilities are
261
  P₀, …, Pₙ₋₁, the device entropy S is defined as
262
  $S = - \sum_{i=0}^{n-1} P_i \cdot \log P_i$.
263
 
264
+ [^6]: b is introduced to avoid any attempt to produce more bits of
265
  randomness than can be held in `RealType`.
266
 
267
+ [^7]: The distribution corresponding to this probability density
268
  function is also known (with a possible change of variable) as the
269
  Gumbel Type I, the log-Weibull, or the Fisher-Tippett Type I
270
  distribution.
271
 
272
+ [^8]: [[implimits]] recommends a minimum number of recursively nested
273
  template instantiations. This requirement thus indirectly suggests a
274
  minimum allowable complexity for valarray expressions.
275
 
276
+ [^9]: The intent is to specify an array template that has the minimum
277
  functionality necessary to address aliasing ambiguities and the
278
  proliferation of temporary objects. Thus, the `valarray` template is
279
  neither a matrix class nor a field class. However, it is a very
280
  useful building block for designing such classes.
281
 
282
+ [^10]: This default constructor is essential, since arrays of `valarray`
283
+ can be useful. After initialization, the length of an empty array
284
  can be increased with the `resize` member function.
285
 
286
+ [^11]: This constructor is the preferred method for converting a C array
287
  to a `valarray` object.
288
 
289
+ [^12]: This copy constructor creates a distinct array rather than an
290
  alias. Implementations in which arrays share storage are permitted,
291
  but they would need to implement a copy-on-reference mechanism to
292
  ensure that arrays are conceptually distinct.
293
 
294
+ [^13]: BLAS stands for *Basic Linear Algebra Subprograms*. C++ programs
295
+ can instantiate this class. See, for example, Dongarra, Du Croz,
296
  Duff, and Hammerling: *A set of Level 3 Basic Linear Algebra
297
  Subprograms*; Technical Report MCS-P1-0888, Argonne National
298
  Laboratory (USA), Mathematics and Computer Science Division, August,
299
  1988.
300
 
301
+ [^14]: A mathematical function is mathematically defined for a given set
302
  of argument values (a) if it is explicitly defined for that set of
303
  argument values, or (b) if its limiting value exists and does not
304
  depend on the direction of approach.