libstdc++: numeric_traits.h Source File

libstdc++

experimental/bits/numeric_traits.h
1// Definition of numeric_limits replacement traits P1841R1 -*- C++ -*-
2
3// Copyright (C) 2020-2026 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library. This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.
10
11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14// GNU General Public License for more details.
15
16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.
19
20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23// <http://www.gnu.org/licenses/>.
24
25#ifndef _GLIBCXX_EXPERIMENTAL_BITS_NUMERIC_TRAITS_H
26#define _GLIBCXX_EXPERIMENTAL_BITS_NUMERIC_TRAITS_H
27
28#include <type_traits>
29
30namespace std {
31
32template <template <typename> class _Trait, typename _Tp, typename = void>
33 struct __value_exists_impl : false_type {};
34
35template <template <typename> class _Trait, typename _Tp>
36 struct __value_exists_impl<_Trait, _Tp, void_t<decltype(_Trait<_Tp>::value)>>
37 : true_type {};
38
39template <typename _Tp, bool = is_arithmetic_v<_Tp>>
40 struct __digits_impl {};
41
42template <typename _Tp>
43 struct __digits_impl<_Tp, true>
44 {
45 static inline constexpr int value
46 = sizeof(_Tp) * __CHAR_BIT__ - is_signed_v<_Tp>;
47 };
48
49template <>
50 struct __digits_impl<float, true>
51 { static inline constexpr int value = __FLT_MANT_DIG__; };
52
53template <>
54 struct __digits_impl<double, true>
55 { static inline constexpr int value = __DBL_MANT_DIG__; };
56
57template <>
58 struct __digits_impl<long double, true>
59 { static inline constexpr int value = __LDBL_MANT_DIG__; };
60
61template <typename _Tp, bool = is_arithmetic_v<_Tp>>
62 struct __digits10_impl {};
63
64template <typename _Tp>
65 struct __digits10_impl<_Tp, true>
66 {
67 // The fraction 643/2136 approximates log10(2) to 7 significant digits.
68 static inline constexpr int value = __digits_impl<_Tp>::value * 643L / 2136;
69 };
70
71template <>
72 struct __digits10_impl<float, true>
73 { static inline constexpr int value = __FLT_DIG__; };
74
75template <>
76 struct __digits10_impl<double, true>
77 { static inline constexpr int value = __DBL_DIG__; };
78
79template <>
80 struct __digits10_impl<long double, true>
81 { static inline constexpr int value = __LDBL_DIG__; };
82
83template <typename _Tp, bool = is_arithmetic_v<_Tp>>
84 struct __max_digits10_impl {};
85
86template <typename _Tp>
87 struct __max_digits10_impl<_Tp, true>
88 {
89 static inline constexpr int value
90 = is_floating_point_v<_Tp> ? 2 + __digits_impl<_Tp>::value * 643L / 2136
91 : __digits10_impl<_Tp>::value + 1;
92 };
93
94template <typename _Tp>
95 struct __max_exponent_impl {};
96
97template <>
98 struct __max_exponent_impl<float>
99 { static inline constexpr int value = __FLT_MAX_EXP__; };
100
101template <>
102 struct __max_exponent_impl<double>
103 { static inline constexpr int value = __DBL_MAX_EXP__; };
104
105template <>
106 struct __max_exponent_impl<long double>
107 { static inline constexpr int value = __LDBL_MAX_EXP__; };
108
109template <typename _Tp>
110 struct __max_exponent10_impl {};
111
112template <>
113 struct __max_exponent10_impl<float>
114 { static inline constexpr int value = __FLT_MAX_10_EXP__; };
115
116template <>
117 struct __max_exponent10_impl<double>
118 { static inline constexpr int value = __DBL_MAX_10_EXP__; };
119
120template <>
121 struct __max_exponent10_impl<long double>
122 { static inline constexpr int value = __LDBL_MAX_10_EXP__; };
123
124template <typename _Tp>
125 struct __min_exponent_impl {};
126
127template <>
128 struct __min_exponent_impl<float>
129 { static inline constexpr int value = __FLT_MIN_EXP__; };
130
131template <>
132 struct __min_exponent_impl<double>
133 { static inline constexpr int value = __DBL_MIN_EXP__; };
134
135template <>
136 struct __min_exponent_impl<long double>
137 { static inline constexpr int value = __LDBL_MIN_EXP__; };
138
139template <typename _Tp>
140 struct __min_exponent10_impl {};
141
142template <>
143 struct __min_exponent10_impl<float>
144 { static inline constexpr int value = __FLT_MIN_10_EXP__; };
145
146template <>
147 struct __min_exponent10_impl<double>
148 { static inline constexpr int value = __DBL_MIN_10_EXP__; };
149
150template <>
151 struct __min_exponent10_impl<long double>
152 { static inline constexpr int value = __LDBL_MIN_10_EXP__; };
153
154template <typename _Tp, bool = is_arithmetic_v<_Tp>>
155 struct __radix_impl {};
156
157template <typename _Tp>
158 struct __radix_impl<_Tp, true>
159 {
160 static inline constexpr int value
161 = is_floating_point_v<_Tp> ? __FLT_RADIX__ : 2;
162 };
163
164// [num.traits.util], numeric utility traits
165template <template <typename> class _Trait, typename _Tp>
166 struct __value_exists : __value_exists_impl<_Trait, _Tp> {};
167
168template <template <typename> class _Trait, typename _Tp>
169 inline constexpr bool __value_exists_v = __value_exists<_Trait, _Tp>::value;
170
171template <template <typename> class _Trait, typename _Tp, typename _Up = _Tp>
172 inline constexpr _Up
173 __value_or(_Up __def = _Up()) noexcept
174 {
175 if constexpr (__value_exists_v<_Trait, _Tp>)
176 return static_cast<_Up>(_Trait<_Tp>::value);
177 else
178 return __def;
179 }
180
181template <typename _Tp, bool = is_arithmetic_v<_Tp>>
182 struct __norm_min_impl {};
183
184template <typename _Tp>
185 struct __norm_min_impl<_Tp, true>
186 { static inline constexpr _Tp value = 1; };
187
188template <>
189 struct __norm_min_impl<float, true>
190 { static inline constexpr float value = __FLT_MIN__; };
191
192template <>
193 struct __norm_min_impl<double, true>
194 { static inline constexpr double value = __DBL_MIN__; };
195
196template <>
197 struct __norm_min_impl<long double, true>
198 { static inline constexpr long double value = __LDBL_MIN__; };
199
200template <typename _Tp>
201 struct __denorm_min_impl : __norm_min_impl<_Tp> {};
202
203#if __FLT_HAS_DENORM__
204template <>
205 struct __denorm_min_impl<float>
206 { static inline constexpr float value = __FLT_DENORM_MIN__; };
207#endif
208
209#if __DBL_HAS_DENORM__
210template <>
211 struct __denorm_min_impl<double>
212 { static inline constexpr double value = __DBL_DENORM_MIN__; };
213#endif
214
215#if __LDBL_HAS_DENORM__
216template <>
217 struct __denorm_min_impl<long double>
218 { static inline constexpr long double value = __LDBL_DENORM_MIN__; };
219#endif
220
221template <typename _Tp>
222 struct __epsilon_impl {};
223
224template <>
225 struct __epsilon_impl<float>
226 { static inline constexpr float value = __FLT_EPSILON__; };
227
228template <>
229 struct __epsilon_impl<double>
230 { static inline constexpr double value = __DBL_EPSILON__; };
231
232template <>
233 struct __epsilon_impl<long double>
234 { static inline constexpr long double value = __LDBL_EPSILON__; };
235
236template <typename _Tp, bool = is_arithmetic_v<_Tp>>
237 struct __finite_min_impl {};
238
239template <typename _Tp>
240 struct __finite_min_impl<_Tp, true>
241 {
242 static inline constexpr _Tp value
243 = is_unsigned_v<_Tp> ? _Tp()
244 : -2 * (_Tp(1) << __digits_impl<_Tp>::value - 1);
245 };
246
247template <>
248 struct __finite_min_impl<float, true>
249 { static inline constexpr float value = -__FLT_MAX__; };
250
251template <>
252 struct __finite_min_impl<double, true>
253 { static inline constexpr double value = -__DBL_MAX__; };
254
255template <>
256 struct __finite_min_impl<long double, true>
257 { static inline constexpr long double value = -__LDBL_MAX__; };
258
259template <typename _Tp, bool = is_arithmetic_v<_Tp>>
260 struct __finite_max_impl {};
261
262template <typename _Tp>
263 struct __finite_max_impl<_Tp, true>
264 { static inline constexpr _Tp value = ~__finite_min_impl<_Tp>::value; };
265
266template <>
267 struct __finite_max_impl<float, true>
268 { static inline constexpr float value = __FLT_MAX__; };
269
270template <>
271 struct __finite_max_impl<double, true>
272 { static inline constexpr double value = __DBL_MAX__; };
273
274template <>
275 struct __finite_max_impl<long double, true>
276 { static inline constexpr long double value = __LDBL_MAX__; };
277
278template <typename _Tp>
279 struct __infinity_impl {};
280
281#if __FLT_HAS_INFINITY__
282template <>
283 struct __infinity_impl<float>
284 { static inline constexpr float value = __builtin_inff(); };
285#endif
286
287#if __DBL_HAS_INFINITY__
288template <>
289 struct __infinity_impl<double>
290 { static inline constexpr double value = __builtin_inf(); };
291#endif
292
293#if __LDBL_HAS_INFINITY__
294template <>
295 struct __infinity_impl<long double>
296 { static inline constexpr long double value = __builtin_infl(); };
297#endif
298
299template <typename _Tp>
300 struct __quiet_NaN_impl {};
301
302#if __FLT_HAS_QUIET_NAN__
303template <>
304 struct __quiet_NaN_impl<float>
305 { static inline constexpr float value = __builtin_nanf(""); };
306#endif
307
308#if __DBL_HAS_QUIET_NAN__
309template <>
310 struct __quiet_NaN_impl<double>
311 { static inline constexpr double value = __builtin_nan(""); };
312#endif
313
314#if __LDBL_HAS_QUIET_NAN__
315template <>
316 struct __quiet_NaN_impl<long double>
317 { static inline constexpr long double value = __builtin_nanl(""); };
318#endif
319
320template <typename _Tp, bool = is_floating_point_v<_Tp>>
321 struct __reciprocal_overflow_threshold_impl {};
322
323template <typename _Tp>
324 struct __reciprocal_overflow_threshold_impl<_Tp, true>
325 {
326 // This typically yields a subnormal value. Is this incorrect for
327 // flush-to-zero configurations?
328 static constexpr _Tp _S_search(_Tp __ok, _Tp __overflows)
329 {
330 const _Tp __mid = (__ok + __overflows) / 2;
331 // 1/__mid without -ffast-math is not a constant expression if it
332 // overflows. Therefore divide 1 by the radix before division.
333 // Consequently finite_max (the threshold) must be scaled by the
334 // same value.
335 if (__mid == __ok || __mid == __overflows)
336 return __ok;
337 else if (_Tp(1) / (__radix_impl<_Tp>::value * __mid)
338 <= __finite_max_impl<_Tp>::value / __radix_impl<_Tp>::value)
339 return _S_search(__mid, __overflows);
340 else
341 return _S_search(__ok, __mid);
342 }
343
344 static inline constexpr _Tp value
345 = _S_search(_Tp(1.01) / __finite_max_impl<_Tp>::value,
346 _Tp(0.99) / __finite_max_impl<_Tp>::value);
347 };
348
349template <typename _Tp, bool = is_floating_point_v<_Tp>>
350 struct __round_error_impl {};
351
352template <typename _Tp>
353 struct __round_error_impl<_Tp, true>
354 { static inline constexpr _Tp value = 0.5; };
355
356template <typename _Tp>
357 struct __signaling_NaN_impl {};
358
359#if __FLT_HAS_QUIET_NAN__
360template <>
361 struct __signaling_NaN_impl<float>
362 { static inline constexpr float value = __builtin_nansf(""); };
363#endif
364
365#if __DBL_HAS_QUIET_NAN__
366template <>
367 struct __signaling_NaN_impl<double>
368 { static inline constexpr double value = __builtin_nans(""); };
369#endif
370
371#if __LDBL_HAS_QUIET_NAN__
372template <>
373 struct __signaling_NaN_impl<long double>
374 { static inline constexpr long double value = __builtin_nansl(""); };
375#endif
376
377// [num.traits.val], numeric distinguished value traits
378template <typename _Tp>
379 struct __denorm_min : __denorm_min_impl<remove_cv_t<_Tp>> {};
380
381template <typename _Tp>
382 struct __epsilon : __epsilon_impl<remove_cv_t<_Tp>> {};
383
384template <typename _Tp>
385 struct __finite_max : __finite_max_impl<remove_cv_t<_Tp>> {};
386
387template <typename _Tp>
388 struct __finite_min : __finite_min_impl<remove_cv_t<_Tp>> {};
389
390template <typename _Tp>
391 struct __infinity : __infinity_impl<remove_cv_t<_Tp>> {};
392
393template <typename _Tp>
394 struct __norm_min : __norm_min_impl<remove_cv_t<_Tp>> {};
395
396template <typename _Tp>
397 struct __quiet_NaN : __quiet_NaN_impl<remove_cv_t<_Tp>> {};
398
399template <typename _Tp>
400 struct __reciprocal_overflow_threshold
401 : __reciprocal_overflow_threshold_impl<remove_cv_t<_Tp>> {};
402
403template <typename _Tp>
404 struct __round_error : __round_error_impl<remove_cv_t<_Tp>> {};
405
406template <typename _Tp>
407 struct __signaling_NaN : __signaling_NaN_impl<remove_cv_t<_Tp>> {};
408
409template <typename _Tp>
410 inline constexpr auto __denorm_min_v = __denorm_min<_Tp>::value;
411
412template <typename _Tp>
413 inline constexpr auto __epsilon_v = __epsilon<_Tp>::value;
414
415template <typename _Tp>
416 inline constexpr auto __finite_max_v = __finite_max<_Tp>::value;
417
418template <typename _Tp>
419 inline constexpr auto __finite_min_v = __finite_min<_Tp>::value;
420
421template <typename _Tp>
422 inline constexpr auto __infinity_v = __infinity<_Tp>::value;
423
424template <typename _Tp>
425 inline constexpr auto __norm_min_v = __norm_min<_Tp>::value;
426
427template <typename _Tp>
428 inline constexpr auto __quiet_NaN_v = __quiet_NaN<_Tp>::value;
429
430template <typename _Tp>
431 inline constexpr auto __reciprocal_overflow_threshold_v
432 = __reciprocal_overflow_threshold<_Tp>::value;
433
434template <typename _Tp>
435 inline constexpr auto __round_error_v = __round_error<_Tp>::value;
436
437template <typename _Tp>
438 inline constexpr auto __signaling_NaN_v = __signaling_NaN<_Tp>::value;
439
440// [num.traits.char], numeric characteristics traits
441template <typename _Tp>
442 struct __digits : __digits_impl<remove_cv_t<_Tp>> {};
443
444template <typename _Tp>
445 struct __digits10 : __digits10_impl<remove_cv_t<_Tp>> {};
446
447template <typename _Tp>
448 struct __max_digits10 : __max_digits10_impl<remove_cv_t<_Tp>> {};
449
450template <typename _Tp>
451 struct __max_exponent : __max_exponent_impl<remove_cv_t<_Tp>> {};
452
453template <typename _Tp>
454 struct __max_exponent10 : __max_exponent10_impl<remove_cv_t<_Tp>> {};
455
456template <typename _Tp>
457 struct __min_exponent : __min_exponent_impl<remove_cv_t<_Tp>> {};
458
459template <typename _Tp>
460 struct __min_exponent10 : __min_exponent10_impl<remove_cv_t<_Tp>> {};
461
462template <typename _Tp>
463 struct __radix : __radix_impl<remove_cv_t<_Tp>> {};
464
465template <typename _Tp>
466 inline constexpr auto __digits_v = __digits<_Tp>::value;
467
468template <typename _Tp>
469 inline constexpr auto __digits10_v = __digits10<_Tp>::value;
470
471template <typename _Tp>
472 inline constexpr auto __max_digits10_v = __max_digits10<_Tp>::value;
473
474template <typename _Tp>
475 inline constexpr auto __max_exponent_v = __max_exponent<_Tp>::value;
476
477template <typename _Tp>
478 inline constexpr auto __max_exponent10_v = __max_exponent10<_Tp>::value;
479
480template <typename _Tp>
481 inline constexpr auto __min_exponent_v = __min_exponent<_Tp>::value;
482
483template <typename _Tp>
484 inline constexpr auto __min_exponent10_v = __min_exponent10<_Tp>::value;
485
486template <typename _Tp>
487 inline constexpr auto __radix_v = __radix<_Tp>::value;
488
489// mkretz's extensions
490// TODO: does GCC tell me? __GCC_IEC_559 >= 2 is not the right answer
491template <typename _Tp>
492 struct __has_iec559_storage_format : true_type {};
493
494template <typename _Tp>
495 inline constexpr bool __has_iec559_storage_format_v
496 = __has_iec559_storage_format<_Tp>::value;
497
498/* To propose:
499 If __has_iec559_behavior<__quiet_NaN, T> is true the following holds:
500 - nan == nan is false
501 - isnan(nan) is true
502 - isnan(nan + x) is true
503 - isnan(inf/inf) is true
504 - isnan(0/0) is true
505 - isunordered(nan, x) is true
506
507 If __has_iec559_behavior<__infinity, T> is true the following holds (x is
508 neither nan nor inf):
509 - isinf(inf) is true
510 - isinf(inf + x) is true
511 - isinf(1/0) is true
512 */
513template <template <typename> class _Trait, typename _Tp>
514 struct __has_iec559_behavior : false_type {};
515
516template <template <typename> class _Trait, typename _Tp>
517 inline constexpr bool __has_iec559_behavior_v
518 = __has_iec559_behavior<_Trait, _Tp>::value;
519
520#if !__FINITE_MATH_ONLY__
521#if __FLT_HAS_QUIET_NAN__
522template <>
523 struct __has_iec559_behavior<__quiet_NaN, float> : true_type {};
524#endif
525
526#if __DBL_HAS_QUIET_NAN__
527template <>
528 struct __has_iec559_behavior<__quiet_NaN, double> : true_type {};
529#endif
530
531#if __LDBL_HAS_QUIET_NAN__
532template <>
533 struct __has_iec559_behavior<__quiet_NaN, long double> : true_type {};
534#endif
535
536#if __FLT_HAS_INFINITY__
537template <>
538 struct __has_iec559_behavior<__infinity, float> : true_type {};
539#endif
540
541#if __DBL_HAS_INFINITY__
542template <>
543 struct __has_iec559_behavior<__infinity, double> : true_type {};
544#endif
545
546#if __LDBL_HAS_INFINITY__
547template <>
548 struct __has_iec559_behavior<__infinity, long double> : true_type {};
549#endif
550
551#ifdef __SUPPORT_SNAN__
552#if __FLT_HAS_QUIET_NAN__
553template <>
554 struct __has_iec559_behavior<__signaling_NaN, float> : true_type {};
555#endif
556
557#if __DBL_HAS_QUIET_NAN__
558template <>
559 struct __has_iec559_behavior<__signaling_NaN, double> : true_type {};
560#endif
561
562#if __LDBL_HAS_QUIET_NAN__
563template <>
564 struct __has_iec559_behavior<__signaling_NaN, long double> : true_type {};
565#endif
566
567#endif
568#endif // __FINITE_MATH_ONLY__
569
570} // namespace std
571#endif // _GLIBCXX_EXPERIMENTAL_BITS_NUMERIC_TRAITS_H
type_traits
std::true_type
__bool_constant< true > true_type
The type used as a compile-time boolean with true value.
Definition type_traits:119
std::false_type
__bool_constant< false > false_type
The type used as a compile-time boolean with false value.
Definition type_traits:122
std::experimental::fundamentals_v2::void_t
void void_t
A metafunction that always yields void, used for detecting valid types.
Definition experimental/type_traits:262
std
ISO C++ entities toplevel namespace is std.