libstdc++

limits
Go to the documentation of this file.
1 // The template and inlines for the numeric_limits classes. -*- C++ -*-
2
3 // Copyright (C) 1999-2013 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 /** @file include/limits
26 * This is a Standard C++ Library header.
27 */
28
29 // Note: this is not a conforming implementation.
30 // Written by Gabriel Dos Reis <gdr@codesourcery.com>
31
32 //
33 // ISO 14882:1998
34 // 18.2.1
35 //
36
37 #ifndef _GLIBCXX_NUMERIC_LIMITS
38 #define _GLIBCXX_NUMERIC_LIMITS 1
39
40 #pragma GCC system_header
41
42 #include <bits/c++config.h>
43
44 //
45 // The numeric_limits<> traits document implementation-defined aspects
46 // of fundamental arithmetic data types (integers and floating points).
47 // From Standard C++ point of view, there are 14 such types:
48 // * integers
49 // bool (1)
50 // char, signed char, unsigned char, wchar_t (4)
51 // short, unsigned short (2)
52 // int, unsigned (2)
53 // long, unsigned long (2)
54 //
55 // * floating points
56 // float (1)
57 // double (1)
58 // long double (1)
59 //
60 // GNU C++ understands (where supported by the host C-library)
61 // * integer
62 // long long, unsigned long long (2)
63 //
64 // which brings us to 16 fundamental arithmetic data types in GNU C++.
65 //
66 //
67 // Since a numeric_limits<> is a bit tricky to get right, we rely on
68 // an interface composed of macros which should be defined in config/os
69 // or config/cpu when they differ from the generic (read arbitrary)
70 // definitions given here.
71 //
72
73 // These values can be overridden in the target configuration file.
74 // The default values are appropriate for many 32-bit targets.
75
76 // GCC only intrinsically supports modulo integral types. The only remaining
77 // integral exceptional values is division by zero. Only targets that do not
78 // signal division by zero in some "hard to ignore" way should use false.
79 #ifndef __glibcxx_integral_traps
80 # define __glibcxx_integral_traps true
81 #endif
82
83 // float
84 //
85
86 // Default values. Should be overridden in configuration files if necessary.
87
88 #ifndef __glibcxx_float_has_denorm_loss
89 # define __glibcxx_float_has_denorm_loss false
90 #endif
91 #ifndef __glibcxx_float_traps
92 # define __glibcxx_float_traps false
93 #endif
94 #ifndef __glibcxx_float_tinyness_before
95 # define __glibcxx_float_tinyness_before false
96 #endif
97
98 // double
99
100 // Default values. Should be overridden in configuration files if necessary.
101
102 #ifndef __glibcxx_double_has_denorm_loss
103 # define __glibcxx_double_has_denorm_loss false
104 #endif
105 #ifndef __glibcxx_double_traps
106 # define __glibcxx_double_traps false
107 #endif
108 #ifndef __glibcxx_double_tinyness_before
109 # define __glibcxx_double_tinyness_before false
110 #endif
111
112 // long double
113
114 // Default values. Should be overridden in configuration files if necessary.
115
116 #ifndef __glibcxx_long_double_has_denorm_loss
117 # define __glibcxx_long_double_has_denorm_loss false
118 #endif
119 #ifndef __glibcxx_long_double_traps
120 # define __glibcxx_long_double_traps false
121 #endif
122 #ifndef __glibcxx_long_double_tinyness_before
123 # define __glibcxx_long_double_tinyness_before false
124 #endif
125
126 // You should not need to define any macros below this point.
127
128 #define __glibcxx_signed(T) ((T)(-1) < 0)
129
130 #define __glibcxx_min(T) \
131 (__glibcxx_signed (T) ? -__glibcxx_max (T) - 1 : (T)0)
132
133 #define __glibcxx_max(T) \
134 (__glibcxx_signed (T) ? \
135 (((((T)1 << (__glibcxx_digits (T) - 1)) - 1) << 1) + 1) : ~(T)0)
136
137 #define __glibcxx_digits(T) \
138 (sizeof(T) * __CHAR_BIT__ - __glibcxx_signed (T))
139
140 // The fraction 643/2136 approximates log10(2) to 7 significant digits.
141 #define __glibcxx_digits10(T) \
142 (__glibcxx_digits (T) * 643L / 2136)
143
144 #define __glibcxx_max_digits10(T) \
145 (2 + (T) * 643L / 2136)
146
147 namespace std _GLIBCXX_VISIBILITY(default)
148 {
149 _GLIBCXX_BEGIN_NAMESPACE_VERSION
150
151 /**
152 * @brief Describes the rounding style for floating-point types.
153 *
154 * This is used in the std::numeric_limits class.
155 */
156 enum float_round_style
157 {
158 round_indeterminate = -1, /// Intermediate.
159 round_toward_zero = 0, /// To zero.
160 round_to_nearest = 1, /// To the nearest representable value.
161 round_toward_infinity = 2, /// To infinity.
162 round_toward_neg_infinity = 3 /// To negative infinity.
163 };
164
165 /**
166 * @brief Describes the denormalization for floating-point types.
167 *
168 * These values represent the presence or absence of a variable number
169 * of exponent bits. This type is used in the std::numeric_limits class.
170 */
171 enum float_denorm_style
172 {
173 /// Indeterminate at compile time whether denormalized values are allowed.
174 denorm_indeterminate = -1,
175 /// The type does not allow denormalized values.
176 denorm_absent = 0,
177 /// The type allows denormalized values.
178 denorm_present = 1
179 };
180
181 /**
182 * @brief Part of std::numeric_limits.
183 *
184 * The @c static @c const members are usable as integral constant
185 * expressions.
186 *
187 * @note This is a separate class for purposes of efficiency; you
188 * should only access these members as part of an instantiation
189 * of the std::numeric_limits class.
190 */
191 struct __numeric_limits_base
192 {
193 /** This will be true for all fundamental types (which have
194 specializations), and false for everything else. */
195 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = false;
196
197 /** The number of @c radix digits that be represented without change: for
198 integer types, the number of non-sign bits in the mantissa; for
199 floating types, the number of @c radix digits in the mantissa. */
200 static _GLIBCXX_USE_CONSTEXPR int digits = 0;
201
202 /** The number of base 10 digits that can be represented without change. */
203 static _GLIBCXX_USE_CONSTEXPR int digits10 = 0;
204
205 #if __cplusplus >= 201103L
206 /** The number of base 10 digits required to ensure that values which
207 differ are always differentiated. */
208 static constexpr int max_digits10 = 0;
209 #endif
210
211 /** True if the type is signed. */
212 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
213
214 /** True if the type is integer. */
215 static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
216
217 /** True if the type uses an exact representation. All integer types are
218 exact, but not all exact types are integer. For example, rational and
219 fixed-exponent representations are exact but not integer. */
220 static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
221
222 /** For integer types, specifies the base of the representation. For
223 floating types, specifies the base of the exponent representation. */
224 static _GLIBCXX_USE_CONSTEXPR int radix = 0;
225
226 /** The minimum negative integer such that @c radix raised to the power of
227 (one less than that integer) is a normalized floating point number. */
228 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
229
230 /** The minimum negative integer such that 10 raised to that power is in
231 the range of normalized floating point numbers. */
232 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
233
234 /** The maximum positive integer such that @c radix raised to the power of
235 (one less than that integer) is a representable finite floating point
236 number. */
237 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
238
239 /** The maximum positive integer such that 10 raised to that power is in
240 the range of representable finite floating point numbers. */
241 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
242
243 /** True if the type has a representation for positive infinity. */
244 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
245
246 /** True if the type has a representation for a quiet (non-signaling)
247 Not a Number. */
248 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
249
250 /** True if the type has a representation for a signaling
251 Not a Number. */
252 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
253
254 /** See std::float_denorm_style for more information. */
255 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent;
256
257 /** True if loss of accuracy is detected as a denormalization loss,
258 rather than as an inexact result. */
259 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
260
261 /** True if-and-only-if the type adheres to the IEC 559 standard, also
262 known as IEEE 754. (Only makes sense for floating point types.) */
263 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
264
265 /** True if the set of values representable by the type is
266 finite. All built-in types are bounded, this member would be
267 false for arbitrary precision types. */
268 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = false;
269
270 /** True if the type is @e modulo. A type is modulo if, for any
271 operation involving +, -, or * on values of that type whose
272 result would fall outside the range [min(),max()], the value
273 returned differs from the true value by an integer multiple of
274 max() - min() + 1. On most machines, this is false for floating
275 types, true for unsigned integers, and true for signed integers.
276 See PR22200 about signed integers. */
277 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
278
279 /** True if trapping is implemented for this type. */
280 static _GLIBCXX_USE_CONSTEXPR bool traps = false;
281
282 /** True if tininess is detected before rounding. (see IEC 559) */
283 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
284
285 /** See std::float_round_style for more information. This is only
286 meaningful for floating types; integer types will all be
287 round_toward_zero. */
288 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style =
289 round_toward_zero;
290 };
291
292 /**
293 * @brief Properties of fundamental types.
294 *
295 * This class allows a program to obtain information about the
296 * representation of a fundamental type on a given platform. For
297 * non-fundamental types, the functions will return 0 and the data
298 * members will all be @c false.
299 *
300 * _GLIBCXX_RESOLVE_LIB_DEFECTS: DRs 201 and 184 (hi Gaby!) are
301 * noted, but not incorporated in this documented (yet).
302 */
303 template<typename _Tp>
304 struct numeric_limits : public __numeric_limits_base
305 {
306 /** The minimum finite value, or for floating types with
307 denormalization, the minimum positive normalized value. */
308 static _GLIBCXX_CONSTEXPR _Tp
309 min() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
310
311 /** The maximum finite value. */
312 static _GLIBCXX_CONSTEXPR _Tp
313 max() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
314
315 #if __cplusplus >= 201103L
316 /** A finite value x such that there is no other finite value y
317 * where y < x. */
318 static constexpr _Tp
319 lowest() noexcept { return _Tp(); }
320 #endif
321
322 /** The @e machine @e epsilon: the difference between 1 and the least
323 value greater than 1 that is representable. */
324 static _GLIBCXX_CONSTEXPR _Tp
325 epsilon() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
326
327 /** The maximum rounding error measurement (see LIA-1). */
328 static _GLIBCXX_CONSTEXPR _Tp
329 round_error() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
330
331 /** The representation of positive infinity, if @c has_infinity. */
332 static _GLIBCXX_CONSTEXPR _Tp
333 infinity() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
334
335 /** The representation of a quiet Not a Number,
336 if @c has_quiet_NaN. */
337 static _GLIBCXX_CONSTEXPR _Tp
338 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
339
340 /** The representation of a signaling Not a Number, if
341 @c has_signaling_NaN. */
342 static _GLIBCXX_CONSTEXPR _Tp
343 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
344
345 /** The minimum positive denormalized value. For types where
346 @c has_denorm is false, this is the minimum positive normalized
347 value. */
348 static _GLIBCXX_CONSTEXPR _Tp
349 denorm_min() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
350 };
351
352 #if __cplusplus >= 201103L
353 template<typename _Tp>
354 struct numeric_limits<const _Tp>
355 : public numeric_limits<_Tp> { };
356
357 template<typename _Tp>
358 struct numeric_limits<volatile _Tp>
359 : public numeric_limits<_Tp> { };
360
361 template<typename _Tp>
362 struct numeric_limits<const volatile _Tp>
363 : public numeric_limits<_Tp> { };
364 #endif
365
366 // Now there follow 16 explicit specializations. Yes, 16. Make sure
367 // you get the count right. (18 in c++0x mode)
368
369 /// numeric_limits<bool> specialization.
370 template<>
371 struct numeric_limits<bool>
372 {
373 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
374
375 static _GLIBCXX_CONSTEXPR bool
376 min() _GLIBCXX_USE_NOEXCEPT { return false; }
377
378 static _GLIBCXX_CONSTEXPR bool
379 max() _GLIBCXX_USE_NOEXCEPT { return true; }
380
381 #if __cplusplus >= 201103L
382 static constexpr bool
383 lowest() noexcept { return min(); }
384 #endif
385 static _GLIBCXX_USE_CONSTEXPR int digits = 1;
386 static _GLIBCXX_USE_CONSTEXPR int digits10 = 0;
387 #if __cplusplus >= 201103L
388 static constexpr int max_digits10 = 0;
389 #endif
390 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
391 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
392 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
393 static _GLIBCXX_USE_CONSTEXPR int radix = 2;
394
395 static _GLIBCXX_CONSTEXPR bool
396 epsilon() _GLIBCXX_USE_NOEXCEPT { return false; }
397
398 static _GLIBCXX_CONSTEXPR bool
399 round_error() _GLIBCXX_USE_NOEXCEPT { return false; }
400
401 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
402 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
403 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
404 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
405
406 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
407 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
408 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
409 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
410 = denorm_absent;
411 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
412
413 static _GLIBCXX_CONSTEXPR bool
414 infinity() _GLIBCXX_USE_NOEXCEPT { return false; }
415
416 static _GLIBCXX_CONSTEXPR bool
417 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return false; }
418
419 static _GLIBCXX_CONSTEXPR bool
420 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return false; }
421
422 static _GLIBCXX_CONSTEXPR bool
423 denorm_min() _GLIBCXX_USE_NOEXCEPT { return false; }
424
425 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
426 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
427 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
428
429 // It is not clear what it means for a boolean type to trap.
430 // This is a DR on the LWG issue list. Here, I use integer
431 // promotion semantics.
432 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
433 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
434 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
435 = round_toward_zero;
436 };
437
438 /// numeric_limits<char> specialization.
439 template<>
440 struct numeric_limits<char>
441 {
442 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
443
444 static _GLIBCXX_CONSTEXPR char
445 min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min(char); }
446
447 static _GLIBCXX_CONSTEXPR char
448 max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max(char); }
449
450 #if __cplusplus >= 201103L
451 static constexpr char
452 lowest() noexcept { return min(); }
453 #endif
454
455 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (char);
456 static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (char);
457 #if __cplusplus >= 201103L
458 static constexpr int max_digits10 = 0;
459 #endif
460 static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (char);
461 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
462 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
463 static _GLIBCXX_USE_CONSTEXPR int radix = 2;
464
465 static _GLIBCXX_CONSTEXPR char
466 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
467
468 static _GLIBCXX_CONSTEXPR char
469 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
470
471 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
472 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
473 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
474 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
475
476 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
477 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
478 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
479 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
480 = denorm_absent;
481 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
482
483 static _GLIBCXX_CONSTEXPR
484 char infinity() _GLIBCXX_USE_NOEXCEPT { return char(); }
485
486 static _GLIBCXX_CONSTEXPR char
487 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return char(); }
488
489 static _GLIBCXX_CONSTEXPR char
490 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return char(); }
491
492 static _GLIBCXX_CONSTEXPR char
493 denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<char>(0); }
494
495 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
496 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
497 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = !is_signed;
498
499 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
500 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
501 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
502 = round_toward_zero;
503 };
504
505 /// numeric_limits<signed char> specialization.
506 template<>
507 struct numeric_limits<signed char>
508 {
509 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
510
511 static _GLIBCXX_CONSTEXPR signed char
512 min() _GLIBCXX_USE_NOEXCEPT { return -__SCHAR_MAX__ - 1; }
513
514 static _GLIBCXX_CONSTEXPR signed char
515 max() _GLIBCXX_USE_NOEXCEPT { return __SCHAR_MAX__; }
516
517 #if __cplusplus >= 201103L
518 static constexpr signed char
519 lowest() noexcept { return min(); }
520 #endif
521
522 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (signed char);
523 static _GLIBCXX_USE_CONSTEXPR int digits10
524 = __glibcxx_digits10 (signed char);
525 #if __cplusplus >= 201103L
526 static constexpr int max_digits10 = 0;
527 #endif
528 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
529 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
530 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
531 static _GLIBCXX_USE_CONSTEXPR int radix = 2;
532
533 static _GLIBCXX_CONSTEXPR signed char
534 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
535
536 static _GLIBCXX_CONSTEXPR signed char
537 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
538
539 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
540 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
541 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
542 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
543
544 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
545 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
546 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
547 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
548 = denorm_absent;
549 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
550
551 static _GLIBCXX_CONSTEXPR signed char
552 infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<signed char>(0); }
553
554 static _GLIBCXX_CONSTEXPR signed char
555 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<signed char>(0); }
556
557 static _GLIBCXX_CONSTEXPR signed char
558 signaling_NaN() _GLIBCXX_USE_NOEXCEPT
559 { return static_cast<signed char>(0); }
560
561 static _GLIBCXX_CONSTEXPR signed char
562 denorm_min() _GLIBCXX_USE_NOEXCEPT
563 { return static_cast<signed char>(0); }
564
565 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
566 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
567 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
568
569 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
570 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
571 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
572 = round_toward_zero;
573 };
574
575 /// numeric_limits<unsigned char> specialization.
576 template<>
577 struct numeric_limits<unsigned char>
578 {
579 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
580
581 static _GLIBCXX_CONSTEXPR unsigned char
582 min() _GLIBCXX_USE_NOEXCEPT { return 0; }
583
584 static _GLIBCXX_CONSTEXPR unsigned char
585 max() _GLIBCXX_USE_NOEXCEPT { return __SCHAR_MAX__ * 2U + 1; }
586
587 #if __cplusplus >= 201103L
588 static constexpr unsigned char
589 lowest() noexcept { return min(); }
590 #endif
591
592 static _GLIBCXX_USE_CONSTEXPR int digits
593 = __glibcxx_digits (unsigned char);
594 static _GLIBCXX_USE_CONSTEXPR int digits10
595 = __glibcxx_digits10 (unsigned char);
596 #if __cplusplus >= 201103L
597 static constexpr int max_digits10 = 0;
598 #endif
599 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
600 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
601 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
602 static _GLIBCXX_USE_CONSTEXPR int radix = 2;
603
604 static _GLIBCXX_CONSTEXPR unsigned char
605 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
606
607 static _GLIBCXX_CONSTEXPR unsigned char
608 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
609
610 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
611 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
612 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
613 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
614
615 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
616 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
617 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
618 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
619 = denorm_absent;
620 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
621
622 static _GLIBCXX_CONSTEXPR unsigned char
623 infinity() _GLIBCXX_USE_NOEXCEPT
624 { return static_cast<unsigned char>(0); }
625
626 static _GLIBCXX_CONSTEXPR unsigned char
627 quiet_NaN() _GLIBCXX_USE_NOEXCEPT
628 { return static_cast<unsigned char>(0); }
629
630 static _GLIBCXX_CONSTEXPR unsigned char
631 signaling_NaN() _GLIBCXX_USE_NOEXCEPT
632 { return static_cast<unsigned char>(0); }
633
634 static _GLIBCXX_CONSTEXPR unsigned char
635 denorm_min() _GLIBCXX_USE_NOEXCEPT
636 { return static_cast<unsigned char>(0); }
637
638 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
639 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
640 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
641
642 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
643 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
644 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
645 = round_toward_zero;
646 };
647
648 /// numeric_limits<wchar_t> specialization.
649 template<>
650 struct numeric_limits<wchar_t>
651 {
652 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
653
654 static _GLIBCXX_CONSTEXPR wchar_t
655 min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min (wchar_t); }
656
657 static _GLIBCXX_CONSTEXPR wchar_t
658 max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max (wchar_t); }
659
660 #if __cplusplus >= 201103L
661 static constexpr wchar_t
662 lowest() noexcept { return min(); }
663 #endif
664
665 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (wchar_t);
666 static _GLIBCXX_USE_CONSTEXPR int digits10
667 = __glibcxx_digits10 (wchar_t);
668 #if __cplusplus >= 201103L
669 static constexpr int max_digits10 = 0;
670 #endif
671 static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (wchar_t);
672 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
673 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
674 static _GLIBCXX_USE_CONSTEXPR int radix = 2;
675
676 static _GLIBCXX_CONSTEXPR wchar_t
677 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
678
679 static _GLIBCXX_CONSTEXPR wchar_t
680 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
681
682 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
683 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
684 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
685 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
686
687 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
688 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
689 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
690 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
691 = denorm_absent;
692 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
693
694 static _GLIBCXX_CONSTEXPR wchar_t
695 infinity() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
696
697 static _GLIBCXX_CONSTEXPR wchar_t
698 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
699
700 static _GLIBCXX_CONSTEXPR wchar_t
701 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
702
703 static _GLIBCXX_CONSTEXPR wchar_t
704 denorm_min() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
705
706 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
707 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
708 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = !is_signed;
709
710 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
711 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
712 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
713 = round_toward_zero;
714 };
715
716 #if __cplusplus >= 201103L
717 /// numeric_limits<char16_t> specialization.
718 template<>
719 struct numeric_limits<char16_t>
720 {
721 static constexpr bool is_specialized = true;
722
723 static constexpr char16_t
724 min() noexcept { return __glibcxx_min (char16_t); }
725
726 static constexpr char16_t
727 max() noexcept { return __glibcxx_max (char16_t); }
728
729 static constexpr char16_t
730 lowest() noexcept { return min(); }
731
732 static constexpr int digits = __glibcxx_digits (char16_t);
733 static constexpr int digits10 = __glibcxx_digits10 (char16_t);
734 static constexpr int max_digits10 = 0;
735 static constexpr bool is_signed = __glibcxx_signed (char16_t);
736 static constexpr bool is_integer = true;
737 static constexpr bool is_exact = true;
738 static constexpr int radix = 2;
739
740 static constexpr char16_t
741 epsilon() noexcept { return 0; }
742
743 static constexpr char16_t
744 round_error() noexcept { return 0; }
745
746 static constexpr int min_exponent = 0;
747 static constexpr int min_exponent10 = 0;
748 static constexpr int max_exponent = 0;
749 static constexpr int max_exponent10 = 0;
750
751 static constexpr bool has_infinity = false;
752 static constexpr bool has_quiet_NaN = false;
753 static constexpr bool has_signaling_NaN = false;
754 static constexpr float_denorm_style has_denorm = denorm_absent;
755 static constexpr bool has_denorm_loss = false;
756
757 static constexpr char16_t
758 infinity() noexcept { return char16_t(); }
759
760 static constexpr char16_t
761 quiet_NaN() noexcept { return char16_t(); }
762
763 static constexpr char16_t
764 signaling_NaN() noexcept { return char16_t(); }
765
766 static constexpr char16_t
767 denorm_min() noexcept { return char16_t(); }
768
769 static constexpr bool is_iec559 = false;
770 static constexpr bool is_bounded = true;
771 static constexpr bool is_modulo = !is_signed;
772
773 static constexpr bool traps = __glibcxx_integral_traps;
774 static constexpr bool tinyness_before = false;
775 static constexpr float_round_style round_style = round_toward_zero;
776 };
777
778 /// numeric_limits<char32_t> specialization.
779 template<>
780 struct numeric_limits<char32_t>
781 {
782 static constexpr bool is_specialized = true;
783
784 static constexpr char32_t
785 min() noexcept { return __glibcxx_min (char32_t); }
786
787 static constexpr char32_t
788 max() noexcept { return __glibcxx_max (char32_t); }
789
790 static constexpr char32_t
791 lowest() noexcept { return min(); }
792
793 static constexpr int digits = __glibcxx_digits (char32_t);
794 static constexpr int digits10 = __glibcxx_digits10 (char32_t);
795 static constexpr int max_digits10 = 0;
796 static constexpr bool is_signed = __glibcxx_signed (char32_t);
797 static constexpr bool is_integer = true;
798 static constexpr bool is_exact = true;
799 static constexpr int radix = 2;
800
801 static constexpr char32_t
802 epsilon() noexcept { return 0; }
803
804 static constexpr char32_t
805 round_error() noexcept { return 0; }
806
807 static constexpr int min_exponent = 0;
808 static constexpr int min_exponent10 = 0;
809 static constexpr int max_exponent = 0;
810 static constexpr int max_exponent10 = 0;
811
812 static constexpr bool has_infinity = false;
813 static constexpr bool has_quiet_NaN = false;
814 static constexpr bool has_signaling_NaN = false;
815 static constexpr float_denorm_style has_denorm = denorm_absent;
816 static constexpr bool has_denorm_loss = false;
817
818 static constexpr char32_t
819 infinity() noexcept { return char32_t(); }
820
821 static constexpr char32_t
822 quiet_NaN() noexcept { return char32_t(); }
823
824 static constexpr char32_t
825 signaling_NaN() noexcept { return char32_t(); }
826
827 static constexpr char32_t
828 denorm_min() noexcept { return char32_t(); }
829
830 static constexpr bool is_iec559 = false;
831 static constexpr bool is_bounded = true;
832 static constexpr bool is_modulo = !is_signed;
833
834 static constexpr bool traps = __glibcxx_integral_traps;
835 static constexpr bool tinyness_before = false;
836 static constexpr float_round_style round_style = round_toward_zero;
837 };
838 #endif
839
840 /// numeric_limits<short> specialization.
841 template<>
842 struct numeric_limits<short>
843 {
844 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
845
846 static _GLIBCXX_CONSTEXPR short
847 min() _GLIBCXX_USE_NOEXCEPT { return -__SHRT_MAX__ - 1; }
848
849 static _GLIBCXX_CONSTEXPR short
850 max() _GLIBCXX_USE_NOEXCEPT { return __SHRT_MAX__; }
851
852 #if __cplusplus >= 201103L
853 static constexpr short
854 lowest() noexcept { return min(); }
855 #endif
856
857 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (short);
858 static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (short);
859 #if __cplusplus >= 201103L
860 static constexpr int max_digits10 = 0;
861 #endif
862 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
863 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
864 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
865 static _GLIBCXX_USE_CONSTEXPR int radix = 2;
866
867 static _GLIBCXX_CONSTEXPR short
868 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
869
870 static _GLIBCXX_CONSTEXPR short
871 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
872
873 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
874 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
875 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
876 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
877
878 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
879 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
880 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
881 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
882 = denorm_absent;
883 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
884
885 static _GLIBCXX_CONSTEXPR short
886 infinity() _GLIBCXX_USE_NOEXCEPT { return short(); }
887
888 static _GLIBCXX_CONSTEXPR short
889 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return short(); }
890
891 static _GLIBCXX_CONSTEXPR short
892 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return short(); }
893
894 static _GLIBCXX_CONSTEXPR short
895 denorm_min() _GLIBCXX_USE_NOEXCEPT { return short(); }
896
897 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
898 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
899 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
900
901 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
902 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
903 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
904 = round_toward_zero;
905 };
906
907 /// numeric_limits<unsigned short> specialization.
908 template<>
909 struct numeric_limits<unsigned short>
910 {
911 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
912
913 static _GLIBCXX_CONSTEXPR unsigned short
914 min() _GLIBCXX_USE_NOEXCEPT { return 0; }
915
916 static _GLIBCXX_CONSTEXPR unsigned short
917 max() _GLIBCXX_USE_NOEXCEPT { return __SHRT_MAX__ * 2U + 1; }
918
919 #if __cplusplus >= 201103L
920 static constexpr unsigned short
921 lowest() noexcept { return min(); }
922 #endif
923
924 static _GLIBCXX_USE_CONSTEXPR int digits
925 = __glibcxx_digits (unsigned short);
926 static _GLIBCXX_USE_CONSTEXPR int digits10
927 = __glibcxx_digits10 (unsigned short);
928 #if __cplusplus >= 201103L
929 static constexpr int max_digits10 = 0;
930 #endif
931 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
932 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
933 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
934 static _GLIBCXX_USE_CONSTEXPR int radix = 2;
935
936 static _GLIBCXX_CONSTEXPR unsigned short
937 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
938
939 static _GLIBCXX_CONSTEXPR unsigned short
940 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
941
942 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
943 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
944 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
945 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
946
947 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
948 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
949 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
950 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
951 = denorm_absent;
952 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
953
954 static _GLIBCXX_CONSTEXPR unsigned short
955 infinity() _GLIBCXX_USE_NOEXCEPT
956 { return static_cast<unsigned short>(0); }
957
958 static _GLIBCXX_CONSTEXPR unsigned short
959 quiet_NaN() _GLIBCXX_USE_NOEXCEPT
960 { return static_cast<unsigned short>(0); }
961
962 static _GLIBCXX_CONSTEXPR unsigned short
963 signaling_NaN() _GLIBCXX_USE_NOEXCEPT
964 { return static_cast<unsigned short>(0); }
965
966 static _GLIBCXX_CONSTEXPR unsigned short
967 denorm_min() _GLIBCXX_USE_NOEXCEPT
968 { return static_cast<unsigned short>(0); }
969
970 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
971 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
972 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
973
974 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
975 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
976 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
977 = round_toward_zero;
978 };
979
980 /// numeric_limits<int> specialization.
981 template<>
982 struct numeric_limits<int>
983 {
984 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
985
986 static _GLIBCXX_CONSTEXPR int
987 min() _GLIBCXX_USE_NOEXCEPT { return -__INT_MAX__ - 1; }
988
989 static _GLIBCXX_CONSTEXPR int
990 max() _GLIBCXX_USE_NOEXCEPT { return __INT_MAX__; }
991
992 #if __cplusplus >= 201103L
993 static constexpr int
994 lowest() noexcept { return min(); }
995 #endif
996
997 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (int);
998 static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (int);
999 #if __cplusplus >= 201103L
1000 static constexpr int max_digits10 = 0;
1001 #endif
1002 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1003 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1004 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1005 static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1006
1007 static _GLIBCXX_CONSTEXPR int
1008 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1009
1010 static _GLIBCXX_CONSTEXPR int
1011 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1012
1013 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1014 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1015 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1016 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1017
1018 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1019 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1020 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1021 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1022 = denorm_absent;
1023 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1024
1025 static _GLIBCXX_CONSTEXPR int
1026 infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
1027
1028 static _GLIBCXX_CONSTEXPR int
1029 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
1030
1031 static _GLIBCXX_CONSTEXPR int
1032 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
1033
1034 static _GLIBCXX_CONSTEXPR int
1035 denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
1036
1037 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1038 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1039 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1040
1041 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1042 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1043 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1044 = round_toward_zero;
1045 };
1046
1047 /// numeric_limits<unsigned int> specialization.
1048 template<>
1049 struct numeric_limits<unsigned int>
1050 {
1051 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1052
1053 static _GLIBCXX_CONSTEXPR unsigned int
1054 min() _GLIBCXX_USE_NOEXCEPT { return 0; }
1055
1056 static _GLIBCXX_CONSTEXPR unsigned int
1057 max() _GLIBCXX_USE_NOEXCEPT { return __INT_MAX__ * 2U + 1; }
1058
1059 #if __cplusplus >= 201103L
1060 static constexpr unsigned int
1061 lowest() noexcept { return min(); }
1062 #endif
1063
1064 static _GLIBCXX_USE_CONSTEXPR int digits
1065 = __glibcxx_digits (unsigned int);
1066 static _GLIBCXX_USE_CONSTEXPR int digits10
1067 = __glibcxx_digits10 (unsigned int);
1068 #if __cplusplus >= 201103L
1069 static constexpr int max_digits10 = 0;
1070 #endif
1071 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
1072 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1073 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1074 static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1075
1076 static _GLIBCXX_CONSTEXPR unsigned int
1077 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1078
1079 static _GLIBCXX_CONSTEXPR unsigned int
1080 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1081
1082 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1083 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1084 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1085 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1086
1087 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1088 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1089 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1090 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1091 = denorm_absent;
1092 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1093
1094 static _GLIBCXX_CONSTEXPR unsigned int
1095 infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<unsigned int>(0); }
1096
1097 static _GLIBCXX_CONSTEXPR unsigned int
1098 quiet_NaN() _GLIBCXX_USE_NOEXCEPT
1099 { return static_cast<unsigned int>(0); }
1100
1101 static _GLIBCXX_CONSTEXPR unsigned int
1102 signaling_NaN() _GLIBCXX_USE_NOEXCEPT
1103 { return static_cast<unsigned int>(0); }
1104
1105 static _GLIBCXX_CONSTEXPR unsigned int
1106 denorm_min() _GLIBCXX_USE_NOEXCEPT
1107 { return static_cast<unsigned int>(0); }
1108
1109 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1110 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1111 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1112
1113 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1114 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1115 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1116 = round_toward_zero;
1117 };
1118
1119 /// numeric_limits<long> specialization.
1120 template<>
1121 struct numeric_limits<long>
1122 {
1123 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1124
1125 static _GLIBCXX_CONSTEXPR long
1126 min() _GLIBCXX_USE_NOEXCEPT { return -__LONG_MAX__ - 1; }
1127
1128 static _GLIBCXX_CONSTEXPR long
1129 max() _GLIBCXX_USE_NOEXCEPT { return __LONG_MAX__; }
1130
1131 #if __cplusplus >= 201103L
1132 static constexpr long
1133 lowest() noexcept { return min(); }
1134 #endif
1135
1136 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (long);
1137 static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (long);
1138 #if __cplusplus >= 201103L
1139 static constexpr int max_digits10 = 0;
1140 #endif
1141 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1142 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1143 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1144 static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1145
1146 static _GLIBCXX_CONSTEXPR long
1147 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1148
1149 static _GLIBCXX_CONSTEXPR long
1150 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1151
1152 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1153 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1154 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1155 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1156
1157 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1158 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1159 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1160 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1161 = denorm_absent;
1162 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1163
1164 static _GLIBCXX_CONSTEXPR long
1165 infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
1166
1167 static _GLIBCXX_CONSTEXPR long
1168 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
1169
1170 static _GLIBCXX_CONSTEXPR long
1171 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
1172
1173 static _GLIBCXX_CONSTEXPR long
1174 denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
1175
1176 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1177 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1178 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1179
1180 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1181 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1182 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1183 = round_toward_zero;
1184 };
1185
1186 /// numeric_limits<unsigned long> specialization.
1187 template<>
1188 struct numeric_limits<unsigned long>
1189 {
1190 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1191
1192 static _GLIBCXX_CONSTEXPR unsigned long
1193 min() _GLIBCXX_USE_NOEXCEPT { return 0; }
1194
1195 static _GLIBCXX_CONSTEXPR unsigned long
1196 max() _GLIBCXX_USE_NOEXCEPT { return __LONG_MAX__ * 2UL + 1; }
1197
1198 #if __cplusplus >= 201103L
1199 static constexpr unsigned long
1200 lowest() noexcept { return min(); }
1201 #endif
1202
1203 static _GLIBCXX_USE_CONSTEXPR int digits
1204 = __glibcxx_digits (unsigned long);
1205 static _GLIBCXX_USE_CONSTEXPR int digits10
1206 = __glibcxx_digits10 (unsigned long);
1207 #if __cplusplus >= 201103L
1208 static constexpr int max_digits10 = 0;
1209 #endif
1210 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
1211 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1212 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1213 static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1214
1215 static _GLIBCXX_CONSTEXPR unsigned long
1216 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1217
1218 static _GLIBCXX_CONSTEXPR unsigned long
1219 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1220
1221 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1222 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1223 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1224 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1225
1226 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1227 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1228 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1229 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1230 = denorm_absent;
1231 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1232
1233 static _GLIBCXX_CONSTEXPR unsigned long
1234 infinity() _GLIBCXX_USE_NOEXCEPT
1235 { return static_cast<unsigned long>(0); }
1236
1237 static _GLIBCXX_CONSTEXPR unsigned long
1238 quiet_NaN() _GLIBCXX_USE_NOEXCEPT
1239 { return static_cast<unsigned long>(0); }
1240
1241 static _GLIBCXX_CONSTEXPR unsigned long
1242 signaling_NaN() _GLIBCXX_USE_NOEXCEPT
1243 { return static_cast<unsigned long>(0); }
1244
1245 static _GLIBCXX_CONSTEXPR unsigned long
1246 denorm_min() _GLIBCXX_USE_NOEXCEPT
1247 { return static_cast<unsigned long>(0); }
1248
1249 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1250 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1251 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1252
1253 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1254 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1255 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1256 = round_toward_zero;
1257 };
1258
1259 /// numeric_limits<long long> specialization.
1260 template<>
1261 struct numeric_limits<long long>
1262 {
1263 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1264
1265 static _GLIBCXX_CONSTEXPR long long
1266 min() _GLIBCXX_USE_NOEXCEPT { return -__LONG_LONG_MAX__ - 1; }
1267
1268 static _GLIBCXX_CONSTEXPR long long
1269 max() _GLIBCXX_USE_NOEXCEPT { return __LONG_LONG_MAX__; }
1270
1271 #if __cplusplus >= 201103L
1272 static constexpr long long
1273 lowest() noexcept { return min(); }
1274 #endif
1275
1276 static _GLIBCXX_USE_CONSTEXPR int digits
1277 = __glibcxx_digits (long long);
1278 static _GLIBCXX_USE_CONSTEXPR int digits10
1279 = __glibcxx_digits10 (long long);
1280 #if __cplusplus >= 201103L
1281 static constexpr int max_digits10 = 0;
1282 #endif
1283 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1284 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1285 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1286 static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1287
1288 static _GLIBCXX_CONSTEXPR long long
1289 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1290
1291 static _GLIBCXX_CONSTEXPR long long
1292 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1293
1294 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1295 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1296 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1297 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1298
1299 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1300 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1301 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1302 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1303 = denorm_absent;
1304 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1305
1306 static _GLIBCXX_CONSTEXPR long long
1307 infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); }
1308
1309 static _GLIBCXX_CONSTEXPR long long
1310 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); }
1311
1312 static _GLIBCXX_CONSTEXPR long long
1313 signaling_NaN() _GLIBCXX_USE_NOEXCEPT
1314 { return static_cast<long long>(0); }
1315
1316 static _GLIBCXX_CONSTEXPR long long
1317 denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); }
1318
1319 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1320 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1321 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1322
1323 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1324 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1325 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1326 = round_toward_zero;
1327 };
1328
1329 /// numeric_limits<unsigned long long> specialization.
1330 template<>
1331 struct numeric_limits<unsigned long long>
1332 {
1333 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1334
1335 static _GLIBCXX_CONSTEXPR unsigned long long
1336 min() _GLIBCXX_USE_NOEXCEPT { return 0; }
1337
1338 static _GLIBCXX_CONSTEXPR unsigned long long
1339 max() _GLIBCXX_USE_NOEXCEPT { return __LONG_LONG_MAX__ * 2ULL + 1; }
1340
1341 #if __cplusplus >= 201103L
1342 static constexpr unsigned long long
1343 lowest() noexcept { return min(); }
1344 #endif
1345
1346 static _GLIBCXX_USE_CONSTEXPR int digits
1347 = __glibcxx_digits (unsigned long long);
1348 static _GLIBCXX_USE_CONSTEXPR int digits10
1349 = __glibcxx_digits10 (unsigned long long);
1350 #if __cplusplus >= 201103L
1351 static constexpr int max_digits10 = 0;
1352 #endif
1353 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
1354 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1355 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1356 static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1357
1358 static _GLIBCXX_CONSTEXPR unsigned long long
1359 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1360
1361 static _GLIBCXX_CONSTEXPR unsigned long long
1362 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1363
1364 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1365 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1366 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1367 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1368
1369 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1370 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1371 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1372 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1373 = denorm_absent;
1374 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1375
1376 static _GLIBCXX_CONSTEXPR unsigned long long
1377 infinity() _GLIBCXX_USE_NOEXCEPT
1378 { return static_cast<unsigned long long>(0); }
1379
1380 static _GLIBCXX_CONSTEXPR unsigned long long
1381 quiet_NaN() _GLIBCXX_USE_NOEXCEPT
1382 { return static_cast<unsigned long long>(0); }
1383
1384 static _GLIBCXX_CONSTEXPR unsigned long long
1385 signaling_NaN() _GLIBCXX_USE_NOEXCEPT
1386 { return static_cast<unsigned long long>(0); }
1387
1388 static _GLIBCXX_CONSTEXPR unsigned long long
1389 denorm_min() _GLIBCXX_USE_NOEXCEPT
1390 { return static_cast<unsigned long long>(0); }
1391
1392 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1393 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1394 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1395
1396 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1397 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1398 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1399 = round_toward_zero;
1400 };
1401
1402 #if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_INT128)
1403 /// numeric_limits<__int128> specialization.
1404 template<>
1405 struct numeric_limits<__int128>
1406 {
1407 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1408
1409 static _GLIBCXX_CONSTEXPR __int128
1410 min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min (__int128); }
1411
1412 static _GLIBCXX_CONSTEXPR __int128
1413 max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max (__int128); }
1414
1415 #if __cplusplus >= 201103L
1416 static constexpr __int128
1417 lowest() noexcept { return min(); }
1418 #endif
1419
1420 static _GLIBCXX_USE_CONSTEXPR int digits
1421 = __glibcxx_digits (__int128);
1422 static _GLIBCXX_USE_CONSTEXPR int digits10
1423 = __glibcxx_digits10 (__int128);
1424 #if __cplusplus >= 201103L
1425 static constexpr int max_digits10 = 0;
1426 #endif
1427 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1428 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1429 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1430 static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1431
1432 static _GLIBCXX_CONSTEXPR __int128
1433 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1434
1435 static _GLIBCXX_CONSTEXPR __int128
1436 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1437
1438 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1439 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1440 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1441 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1442
1443 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1444 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1445 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1446 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1447 = denorm_absent;
1448 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1449
1450 static _GLIBCXX_CONSTEXPR __int128
1451 infinity() _GLIBCXX_USE_NOEXCEPT
1452 { return static_cast<__int128>(0); }
1453
1454 static _GLIBCXX_CONSTEXPR __int128
1455 quiet_NaN() _GLIBCXX_USE_NOEXCEPT
1456 { return static_cast<__int128>(0); }
1457
1458 static _GLIBCXX_CONSTEXPR __int128
1459 signaling_NaN() _GLIBCXX_USE_NOEXCEPT
1460 { return static_cast<__int128>(0); }
1461
1462 static _GLIBCXX_CONSTEXPR __int128
1463 denorm_min() _GLIBCXX_USE_NOEXCEPT
1464 { return static_cast<__int128>(0); }
1465
1466 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1467 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1468 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1469
1470 static _GLIBCXX_USE_CONSTEXPR bool traps
1471 = __glibcxx_integral_traps;
1472 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1473 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1474 = round_toward_zero;
1475 };
1476
1477 /// numeric_limits<unsigned __int128> specialization.
1478 template<>
1479 struct numeric_limits<unsigned __int128>
1480 {
1481 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1482
1483 static _GLIBCXX_CONSTEXPR unsigned __int128
1484 min() _GLIBCXX_USE_NOEXCEPT { return 0; }
1485
1486 static _GLIBCXX_CONSTEXPR unsigned __int128
1487 max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max (unsigned __int128); }
1488
1489 #if __cplusplus >= 201103L
1490 static constexpr unsigned __int128
1491 lowest() noexcept { return min(); }
1492 #endif
1493
1494 static _GLIBCXX_USE_CONSTEXPR int digits
1495 = __glibcxx_digits (unsigned __int128);
1496 static _GLIBCXX_USE_CONSTEXPR int digits10
1497 = __glibcxx_digits10 (unsigned __int128);
1498 #if __cplusplus >= 201103L
1499 static constexpr int max_digits10 = 0;
1500 #endif
1501 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
1502 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1503 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1504 static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1505
1506 static _GLIBCXX_CONSTEXPR unsigned __int128
1507 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1508
1509 static _GLIBCXX_CONSTEXPR unsigned __int128
1510 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1511
1512 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1513 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1514 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1515 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1516
1517 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1518 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1519 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1520 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1521 = denorm_absent;
1522 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1523
1524 static _GLIBCXX_CONSTEXPR unsigned __int128
1525 infinity() _GLIBCXX_USE_NOEXCEPT
1526 { return static_cast<unsigned __int128>(0); }
1527
1528 static _GLIBCXX_CONSTEXPR unsigned __int128
1529 quiet_NaN() _GLIBCXX_USE_NOEXCEPT
1530 { return static_cast<unsigned __int128>(0); }
1531
1532 static _GLIBCXX_CONSTEXPR unsigned __int128
1533 signaling_NaN() _GLIBCXX_USE_NOEXCEPT
1534 { return static_cast<unsigned __int128>(0); }
1535
1536 static _GLIBCXX_CONSTEXPR unsigned __int128
1537 denorm_min() _GLIBCXX_USE_NOEXCEPT
1538 { return static_cast<unsigned __int128>(0); }
1539
1540 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1541 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1542 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1543
1544 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1545 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1546 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1547 = round_toward_zero;
1548 };
1549 #endif
1550
1551 /// numeric_limits<float> specialization.
1552 template<>
1553 struct numeric_limits<float>
1554 {
1555 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1556
1557 static _GLIBCXX_CONSTEXPR float
1558 min() _GLIBCXX_USE_NOEXCEPT { return __FLT_MIN__; }
1559
1560 static _GLIBCXX_CONSTEXPR float
1561 max() _GLIBCXX_USE_NOEXCEPT { return __FLT_MAX__; }
1562
1563 #if __cplusplus >= 201103L
1564 static constexpr float
1565 lowest() noexcept { return -__FLT_MAX__; }
1566 #endif
1567
1568 static _GLIBCXX_USE_CONSTEXPR int digits = __FLT_MANT_DIG__;
1569 static _GLIBCXX_USE_CONSTEXPR int digits10 = __FLT_DIG__;
1570 #if __cplusplus >= 201103L
1571 static constexpr int max_digits10
1572 = __glibcxx_max_digits10 (__FLT_MANT_DIG__);
1573 #endif
1574 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1575 static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
1576 static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
1577 static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
1578
1579 static _GLIBCXX_CONSTEXPR float
1580 epsilon() _GLIBCXX_USE_NOEXCEPT { return __FLT_EPSILON__; }
1581
1582 static _GLIBCXX_CONSTEXPR float
1583 round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5F; }
1584
1585 static _GLIBCXX_USE_CONSTEXPR int min_exponent = __FLT_MIN_EXP__;
1586 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __FLT_MIN_10_EXP__;
1587 static _GLIBCXX_USE_CONSTEXPR int max_exponent = __FLT_MAX_EXP__;
1588 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __FLT_MAX_10_EXP__;
1589
1590 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __FLT_HAS_INFINITY__;
1591 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __FLT_HAS_QUIET_NAN__;
1592 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN;
1593 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1594 = bool(__FLT_HAS_DENORM__) ? denorm_present : denorm_absent;
1595 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
1596 = __glibcxx_float_has_denorm_loss;
1597
1598 static _GLIBCXX_CONSTEXPR float
1599 infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_valf(); }
1600
1601 static _GLIBCXX_CONSTEXPR float
1602 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nanf(""); }
1603
1604 static _GLIBCXX_CONSTEXPR float
1605 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nansf(""); }
1606
1607 static _GLIBCXX_CONSTEXPR float
1608 denorm_min() _GLIBCXX_USE_NOEXCEPT { return __FLT_DENORM_MIN__; }
1609
1610 static _GLIBCXX_USE_CONSTEXPR bool is_iec559
1611 = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
1612 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1613 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1614
1615 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_float_traps;
1616 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before
1617 = __glibcxx_float_tinyness_before;
1618 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1619 = round_to_nearest;
1620 };
1621
1622 #undef __glibcxx_float_has_denorm_loss
1623 #undef __glibcxx_float_traps
1624 #undef __glibcxx_float_tinyness_before
1625
1626 /// numeric_limits<double> specialization.
1627 template<>
1628 struct numeric_limits<double>
1629 {
1630 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1631
1632 static _GLIBCXX_CONSTEXPR double
1633 min() _GLIBCXX_USE_NOEXCEPT { return __DBL_MIN__; }
1634
1635 static _GLIBCXX_CONSTEXPR double
1636 max() _GLIBCXX_USE_NOEXCEPT { return __DBL_MAX__; }
1637
1638 #if __cplusplus >= 201103L
1639 static constexpr double
1640 lowest() noexcept { return -__DBL_MAX__; }
1641 #endif
1642
1643 static _GLIBCXX_USE_CONSTEXPR int digits = __DBL_MANT_DIG__;
1644 static _GLIBCXX_USE_CONSTEXPR int digits10 = __DBL_DIG__;
1645 #if __cplusplus >= 201103L
1646 static constexpr int max_digits10
1647 = __glibcxx_max_digits10 (__DBL_MANT_DIG__);
1648 #endif
1649 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1650 static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
1651 static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
1652 static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
1653
1654 static _GLIBCXX_CONSTEXPR double
1655 epsilon() _GLIBCXX_USE_NOEXCEPT { return __DBL_EPSILON__; }
1656
1657 static _GLIBCXX_CONSTEXPR double
1658 round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5; }
1659
1660 static _GLIBCXX_USE_CONSTEXPR int min_exponent = __DBL_MIN_EXP__;
1661 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __DBL_MIN_10_EXP__;
1662 static _GLIBCXX_USE_CONSTEXPR int max_exponent = __DBL_MAX_EXP__;
1663 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __DBL_MAX_10_EXP__;
1664
1665 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __DBL_HAS_INFINITY__;
1666 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __DBL_HAS_QUIET_NAN__;
1667 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN;
1668 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1669 = bool(__DBL_HAS_DENORM__) ? denorm_present : denorm_absent;
1670 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
1671 = __glibcxx_double_has_denorm_loss;
1672
1673 static _GLIBCXX_CONSTEXPR double
1674 infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_val(); }
1675
1676 static _GLIBCXX_CONSTEXPR double
1677 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nan(""); }
1678
1679 static _GLIBCXX_CONSTEXPR double
1680 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nans(""); }
1681
1682 static _GLIBCXX_CONSTEXPR double
1683 denorm_min() _GLIBCXX_USE_NOEXCEPT { return __DBL_DENORM_MIN__; }
1684
1685 static _GLIBCXX_USE_CONSTEXPR bool is_iec559
1686 = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
1687 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1688 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1689
1690 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_double_traps;
1691 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before
1692 = __glibcxx_double_tinyness_before;
1693 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1694 = round_to_nearest;
1695 };
1696
1697 #undef __glibcxx_double_has_denorm_loss
1698 #undef __glibcxx_double_traps
1699 #undef __glibcxx_double_tinyness_before
1700
1701 /// numeric_limits<long double> specialization.
1702 template<>
1703 struct numeric_limits<long double>
1704 {
1705 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1706
1707 static _GLIBCXX_CONSTEXPR long double
1708 min() _GLIBCXX_USE_NOEXCEPT { return __LDBL_MIN__; }
1709
1710 static _GLIBCXX_CONSTEXPR long double
1711 max() _GLIBCXX_USE_NOEXCEPT { return __LDBL_MAX__; }
1712
1713 #if __cplusplus >= 201103L
1714 static constexpr long double
1715 lowest() noexcept { return -__LDBL_MAX__; }
1716 #endif
1717
1718 static _GLIBCXX_USE_CONSTEXPR int digits = __LDBL_MANT_DIG__;
1719 static _GLIBCXX_USE_CONSTEXPR int digits10 = __LDBL_DIG__;
1720 #if __cplusplus >= 201103L
1721 static _GLIBCXX_USE_CONSTEXPR int max_digits10
1722 = __glibcxx_max_digits10 (__LDBL_MANT_DIG__);
1723 #endif
1724 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1725 static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
1726 static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
1727 static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
1728
1729 static _GLIBCXX_CONSTEXPR long double
1730 epsilon() _GLIBCXX_USE_NOEXCEPT { return __LDBL_EPSILON__; }
1731
1732 static _GLIBCXX_CONSTEXPR long double
1733 round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5L; }
1734
1735 static _GLIBCXX_USE_CONSTEXPR int min_exponent = __LDBL_MIN_EXP__;
1736 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __LDBL_MIN_10_EXP__;
1737 static _GLIBCXX_USE_CONSTEXPR int max_exponent = __LDBL_MAX_EXP__;
1738 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __LDBL_MAX_10_EXP__;
1739
1740 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __LDBL_HAS_INFINITY__;
1741 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __LDBL_HAS_QUIET_NAN__;
1742 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN;
1743 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1744 = bool(__LDBL_HAS_DENORM__) ? denorm_present : denorm_absent;
1745 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
1746 = __glibcxx_long_double_has_denorm_loss;
1747
1748 static _GLIBCXX_CONSTEXPR long double
1749 infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_vall(); }
1750
1751 static _GLIBCXX_CONSTEXPR long double
1752 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nanl(""); }
1753
1754 static _GLIBCXX_CONSTEXPR long double
1755 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nansl(""); }
1756
1757 static _GLIBCXX_CONSTEXPR long double
1758 denorm_min() _GLIBCXX_USE_NOEXCEPT { return __LDBL_DENORM_MIN__; }
1759
1760 static _GLIBCXX_USE_CONSTEXPR bool is_iec559
1761 = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
1762 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1763 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1764
1765 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_long_double_traps;
1766 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before =
1767 __glibcxx_long_double_tinyness_before;
1768 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style =
1769 round_to_nearest;
1770 };
1771
1772 #undef __glibcxx_long_double_has_denorm_loss
1773 #undef __glibcxx_long_double_traps
1774 #undef __glibcxx_long_double_tinyness_before
1775
1776 _GLIBCXX_END_NAMESPACE_VERSION
1777 } // namespace
1778
1779 #undef __glibcxx_signed
1780 #undef __glibcxx_min
1781 #undef __glibcxx_max
1782 #undef __glibcxx_digits
1783 #undef __glibcxx_digits10
1784 #undef __glibcxx_max_digits10
1785
1786 #endif // _GLIBCXX_NUMERIC_LIMITS