1 // The template and inlines for the numeric_limits classes. -*- C++ -*-
3 // Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
4 // 2008, 2009, 2010 Free Software Foundation, Inc.
6 // This file is part of the GNU ISO C++ Library. This library is free
7 // software; you can redistribute it and/or modify it under the
8 // terms of the GNU General Public License as published by the
9 // Free Software Foundation; either version 3, or (at your option)
12 // This library is distributed in the hope that it will be useful,
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 // GNU General Public License for more details.
17 // Under Section 7 of GPL version 3, you are granted additional
18 // permissions described in the GCC Runtime Library Exception, version
19 // 3.1, as published by the Free Software Foundation.
21 // You should have received a copy of the GNU General Public License and
22 // a copy of the GCC Runtime Library Exception along with this program;
23 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
24 // <http://www.gnu.org/licenses/>.
26 /** @file include/limits
27 * This is a Standard C++ Library header.
30 // Note: this is not a conforming implementation.
31 // Written by Gabriel Dos Reis <gdr@codesourcery.com>
38 #ifndef _GLIBCXX_NUMERIC_LIMITS
39 #define _GLIBCXX_NUMERIC_LIMITS 1
41 #pragma GCC system_header
43 #include <bits/c++config.h>
46 // The numeric_limits<> traits document implementation-defined aspects
47 // of fundamental arithmetic data types (integers and floating points).
48 // From Standard C++ point of view, there are 14 such types:
51 // char, signed char, unsigned char, wchar_t (4)
52 // short, unsigned short (2)
54 // long, unsigned long (2)
61 // GNU C++ understands (where supported by the host C-library)
63 // long long, unsigned long long (2)
65 // which brings us to 16 fundamental arithmetic data types in GNU C++.
68 // Since a numeric_limits<> is a bit tricky to get right, we rely on
69 // an interface composed of macros which should be defined in config/os
70 // or config/cpu when they differ from the generic (read arbitrary)
71 // definitions given here.
74 // These values can be overridden in the target configuration file.
75 // The default values are appropriate for many 32-bit targets.
77 // GCC only intrinsically supports modulo integral types. The only remaining
78 // integral exceptional values is division by zero. Only targets that do not
79 // signal division by zero in some "hard to ignore" way should use false.
80 #ifndef __glibcxx_integral_traps
81 # define __glibcxx_integral_traps true
87 // Default values. Should be overridden in configuration files if necessary.
89 #ifndef __glibcxx_float_has_denorm_loss
90 # define __glibcxx_float_has_denorm_loss false
92 #ifndef __glibcxx_float_traps
93 # define __glibcxx_float_traps false
95 #ifndef __glibcxx_float_tinyness_before
96 # define __glibcxx_float_tinyness_before false
101 // Default values. Should be overridden in configuration files if necessary.
103 #ifndef __glibcxx_double_has_denorm_loss
104 # define __glibcxx_double_has_denorm_loss false
106 #ifndef __glibcxx_double_traps
107 # define __glibcxx_double_traps false
109 #ifndef __glibcxx_double_tinyness_before
110 # define __glibcxx_double_tinyness_before false
115 // Default values. Should be overridden in configuration files if necessary.
117 #ifndef __glibcxx_long_double_has_denorm_loss
118 # define __glibcxx_long_double_has_denorm_loss false
120 #ifndef __glibcxx_long_double_traps
121 # define __glibcxx_long_double_traps false
123 #ifndef __glibcxx_long_double_tinyness_before
124 # define __glibcxx_long_double_tinyness_before false
127 // You should not need to define any macros below this point.
129 #define __glibcxx_signed(T) ((T)(-1) < 0)
131 #define __glibcxx_min(T) \
132 (__glibcxx_signed (T) ? (T)1 << __glibcxx_digits (T) : (T)0)
134 #define __glibcxx_max(T) \
135 (__glibcxx_signed (T) ? \
136 (((((T)1 << (__glibcxx_digits (T) - 1)) - 1) << 1) + 1) : ~(T)0)
138 #define __glibcxx_digits(T) \
139 (sizeof(T) * __CHAR_BIT__ - __glibcxx_signed (T))
141 // The fraction 643/2136 approximates log10(2) to 7 significant digits.
142 #define __glibcxx_digits10(T) \
143 (__glibcxx_digits (T) * 643L / 2136)
145 #define __glibcxx_max_digits10(T) \
146 (2 + (T) * 643L / 2136)
148 namespace std _GLIBCXX_VISIBILITY(default)
150 _GLIBCXX_BEGIN_NAMESPACE_VERSION
153 * @brief Describes the rounding style for floating-point types.
155 * This is used in the std::numeric_limits class.
157 enum float_round_style
159 round_indeterminate = -1, /// Intermediate.
160 round_toward_zero = 0, /// To zero.
161 round_to_nearest = 1, /// To the nearest representable value.
162 round_toward_infinity = 2, /// To infinity.
163 round_toward_neg_infinity = 3 /// To negative infinity.
167 * @brief Describes the denormalization for floating-point types.
169 * These values represent the presence or absence of a variable number
170 * of exponent bits. This type is used in the std::numeric_limits class.
172 enum float_denorm_style
174 /// Indeterminate at compile time whether denormalized values are allowed.
175 denorm_indeterminate = -1,
176 /// The type does not allow denormalized values.
178 /// The type allows denormalized values.
183 * @brief Part of std::numeric_limits.
185 * The @c static @c const members are usable as integral constant
188 * @note This is a separate class for purposes of efficiency; you
189 * should only access these members as part of an instantiation
190 * of the std::numeric_limits class.
192 struct __numeric_limits_base
194 /** This will be true for all fundamental types (which have
195 specializations), and false for everything else. */
196 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = false;
198 /** The number of @c radix digits that be represented without change: for
199 integer types, the number of non-sign bits in the mantissa; for
200 floating types, the number of @c radix digits in the mantissa. */
201 static _GLIBCXX_USE_CONSTEXPR int digits = 0;
203 /** The number of base 10 digits that can be represented without change. */
204 static _GLIBCXX_USE_CONSTEXPR int digits10 = 0;
206 #ifdef __GXX_EXPERIMENTAL_CXX0X__
207 /** The number of base 10 digits required to ensure that values which
208 differ are always differentiated. */
209 static constexpr int max_digits10 = 0;
212 /** True if the type is signed. */
213 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
215 /** True if the type is integer.
216 * Is this supposed to be <em>if the type is integral?</em> */
217 static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
219 /** True if the type uses an exact representation. <em>All integer types are
220 exact, but not all exact types are integer. For example, rational and
221 fixed-exponent representations are exact but not integer.</em>
223 static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
225 /** For integer types, specifies the base of the representation. For
226 floating types, specifies the base of the exponent representation. */
227 static _GLIBCXX_USE_CONSTEXPR int radix = 0;
229 /** The minimum negative integer such that @c radix raised to the power of
230 (one less than that integer) is a normalized floating point number. */
231 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
233 /** The minimum negative integer such that 10 raised to that power is in
234 the range of normalized floating point numbers. */
235 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
237 /** The maximum positive integer such that @c radix raised to the power of
238 (one less than that integer) is a representable finite floating point
240 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
242 /** The maximum positive integer such that 10 raised to that power is in
243 the range of representable finite floating point numbers. */
244 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
246 /** True if the type has a representation for positive infinity. */
247 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
249 /** True if the type has a representation for a quiet (non-signaling)
250 <em>Not a Number</em>. */
251 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
253 /** True if the type has a representation for a signaling
254 <em>Not a Number</em>. */
255 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
257 /** See std::float_denorm_style for more information. */
258 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent;
260 /** <em>True if loss of accuracy is detected as a denormalization loss,
261 rather than as an inexact result.</em> [18.2.1.2]/42 */
262 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
264 /** True if-and-only-if the type adheres to the IEC 559 standard, also
265 known as IEEE 754. (Only makes sense for floating point types.) */
266 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
268 /** <em>True if the set of values representable by the type is
269 finite. All built-in types are bounded, this member would be
270 false for arbitrary precision types.</em> [18.2.1.2]/54 */
271 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = false;
273 /** True if the type is @e modulo, that is, if it is possible to add two
274 positive numbers and have a result that wraps around to a third number
275 that is less. Typically false for floating types, true for unsigned
276 integers, and true for signed integers. */
277 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
279 /** True if trapping is implemented for this type. */
280 static _GLIBCXX_USE_CONSTEXPR bool traps = false;
282 /** True if tininess is detected before rounding. (see IEC 559) */
283 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
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 =
293 * @brief Properties of fundamental types.
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.
300 * _GLIBCXX_RESOLVE_LIB_DEFECTS: DRs 201 and 184 (hi Gaby!) are
301 * noted, but not incorporated in this documented (yet).
303 template<typename _Tp>
304 struct numeric_limits : public __numeric_limits_base
306 /** The minimum finite value, or for floating types with
307 denormalization, the minimum positive normalized value. */
308 static _GLIBCXX_CONSTEXPR _Tp
309 min() throw() { return static_cast<_Tp>(0); }
311 /** The maximum finite value. */
312 static _GLIBCXX_CONSTEXPR _Tp
313 max() throw() { return static_cast<_Tp>(0); }
315 #ifdef __GXX_EXPERIMENTAL_CXX0X__
316 /** A finite value x such that there is no other finite value y
319 lowest() throw() { return static_cast<_Tp>(0); }
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() throw() { return static_cast<_Tp>(0); }
327 /** The maximum rounding error measurement (see LIA-1). */
328 static _GLIBCXX_CONSTEXPR _Tp
329 round_error() throw() { return static_cast<_Tp>(0); }
331 /** The representation of positive infinity, if @c has_infinity. */
332 static _GLIBCXX_CONSTEXPR _Tp
333 infinity() throw() { return static_cast<_Tp>(0); }
335 /** The representation of a quiet <em>Not a Number</em>,
336 if @c has_quiet_NaN. */
337 static _GLIBCXX_CONSTEXPR _Tp
338 quiet_NaN() throw() { return static_cast<_Tp>(0); }
340 /** The representation of a signaling <em>Not a Number</em>, if
341 @c has_signaling_NaN. */
342 static _GLIBCXX_CONSTEXPR _Tp
343 signaling_NaN() throw() { return static_cast<_Tp>(0); }
345 /** The minimum positive denormalized value. For types where
346 @c has_denorm is false, this is the minimum positive normalized
348 static _GLIBCXX_CONSTEXPR _Tp
349 denorm_min() throw() { return static_cast<_Tp>(0); }
352 #ifdef __GXX_EXPERIMENTAL_CXX0X__
353 template<typename _Tp>
354 struct numeric_limits<const _Tp>
355 : public numeric_limits<_Tp> { };
357 template<typename _Tp>
358 struct numeric_limits<volatile _Tp>
359 : public numeric_limits<_Tp> { };
361 template<typename _Tp>
362 struct numeric_limits<const volatile _Tp>
363 : public numeric_limits<_Tp> { };
366 // Now there follow 16 explicit specializations. Yes, 16. Make sure
367 // you get the count right. (18 in c++0x mode)
369 /// numeric_limits<bool> specialization.
371 struct numeric_limits<bool>
373 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
375 static _GLIBCXX_CONSTEXPR bool
376 min() throw() { return false; }
378 static _GLIBCXX_CONSTEXPR bool
379 max() throw() { return true; }
381 #ifdef __GXX_EXPERIMENTAL_CXX0X__
382 static constexpr bool
383 lowest() throw() { return min(); }
385 static _GLIBCXX_USE_CONSTEXPR int digits = 1;
386 static _GLIBCXX_USE_CONSTEXPR int digits10 = 0;
387 #ifdef __GXX_EXPERIMENTAL_CXX0X__
388 static constexpr int max_digits10 = 0;
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;
395 static _GLIBCXX_CONSTEXPR bool
396 epsilon() throw() { return false; }
398 static _GLIBCXX_CONSTEXPR bool
399 round_error() throw() { return false; }
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;
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
411 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
413 static _GLIBCXX_CONSTEXPR bool
414 infinity() throw() { return false; }
416 static _GLIBCXX_CONSTEXPR bool
417 quiet_NaN() throw() { return false; }
419 static _GLIBCXX_CONSTEXPR bool
420 signaling_NaN() throw() { return false; }
422 static _GLIBCXX_CONSTEXPR bool
423 denorm_min() throw() { return false; }
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;
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
438 /// numeric_limits<char> specialization.
440 struct numeric_limits<char>
442 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
444 static _GLIBCXX_CONSTEXPR char
445 min() throw() { return __glibcxx_min(char); }
447 static _GLIBCXX_CONSTEXPR char
448 max() throw() { return __glibcxx_max(char); }
450 #ifdef __GXX_EXPERIMENTAL_CXX0X__
451 static constexpr char
452 lowest() throw() { return min(); }
455 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (char);
456 static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (char);
457 #ifdef __GXX_EXPERIMENTAL_CXX0X__
458 static constexpr int max_digits10 = 0;
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;
465 static _GLIBCXX_CONSTEXPR char
466 epsilon() throw() { return 0; }
468 static _GLIBCXX_CONSTEXPR char
469 round_error() throw() { return 0; }
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;
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
481 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
483 static _GLIBCXX_CONSTEXPR
484 char infinity() throw() { return char(); }
486 static _GLIBCXX_CONSTEXPR char
487 quiet_NaN() throw() { return char(); }
489 static _GLIBCXX_CONSTEXPR char
490 signaling_NaN() throw() { return char(); }
492 static _GLIBCXX_CONSTEXPR char
493 denorm_min() throw() { return static_cast<char>(0); }
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 = true;
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
505 /// numeric_limits<signed char> specialization.
507 struct numeric_limits<signed char>
509 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
511 static _GLIBCXX_CONSTEXPR signed char
512 min() throw() { return -__SCHAR_MAX__ - 1; }
514 static _GLIBCXX_CONSTEXPR signed char
515 max() throw() { return __SCHAR_MAX__; }
517 #ifdef __GXX_EXPERIMENTAL_CXX0X__
518 static constexpr signed char
519 lowest() throw() { return min(); }
522 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (signed char);
523 static _GLIBCXX_USE_CONSTEXPR int digits10
524 = __glibcxx_digits10 (signed char);
525 #ifdef __GXX_EXPERIMENTAL_CXX0X__
526 static constexpr int max_digits10 = 0;
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;
533 static _GLIBCXX_CONSTEXPR signed char
534 epsilon() throw() { return 0; }
536 static _GLIBCXX_CONSTEXPR signed char
537 round_error() throw() { return 0; }
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;
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
549 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
551 static _GLIBCXX_CONSTEXPR signed char
552 infinity() throw() { return static_cast<signed char>(0); }
554 static _GLIBCXX_CONSTEXPR signed char
555 quiet_NaN() throw() { return static_cast<signed char>(0); }
557 static _GLIBCXX_CONSTEXPR signed char
558 signaling_NaN() throw() { return static_cast<signed char>(0); }
560 static _GLIBCXX_CONSTEXPR signed char
561 denorm_min() throw() { return static_cast<signed char>(0); }
563 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
564 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
565 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
567 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
568 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
569 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
573 /// numeric_limits<unsigned char> specialization.
575 struct numeric_limits<unsigned char>
577 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
579 static _GLIBCXX_CONSTEXPR unsigned char
580 min() throw() { return 0; }
582 static _GLIBCXX_CONSTEXPR unsigned char
583 max() throw() { return __SCHAR_MAX__ * 2U + 1; }
585 #ifdef __GXX_EXPERIMENTAL_CXX0X__
586 static constexpr unsigned char
587 lowest() throw() { return min(); }
590 static _GLIBCXX_USE_CONSTEXPR int digits
591 = __glibcxx_digits (unsigned char);
592 static _GLIBCXX_USE_CONSTEXPR int digits10
593 = __glibcxx_digits10 (unsigned char);
594 #ifdef __GXX_EXPERIMENTAL_CXX0X__
595 static constexpr int max_digits10 = 0;
597 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
598 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
599 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
600 static _GLIBCXX_USE_CONSTEXPR int radix = 2;
602 static _GLIBCXX_CONSTEXPR unsigned char
603 epsilon() throw() { return 0; }
605 static _GLIBCXX_CONSTEXPR unsigned char
606 round_error() throw() { return 0; }
608 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
609 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
610 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
611 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
613 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
614 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
615 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
616 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
618 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
620 static _GLIBCXX_CONSTEXPR unsigned char
621 infinity() throw() { return static_cast<unsigned char>(0); }
623 static _GLIBCXX_CONSTEXPR unsigned char
624 quiet_NaN() throw() { return static_cast<unsigned char>(0); }
626 static _GLIBCXX_CONSTEXPR unsigned char
627 signaling_NaN() throw() { return static_cast<unsigned char>(0); }
629 static _GLIBCXX_CONSTEXPR unsigned char
630 denorm_min() throw() { return static_cast<unsigned char>(0); }
632 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
633 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
634 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
636 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
637 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
638 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
642 /// numeric_limits<wchar_t> specialization.
644 struct numeric_limits<wchar_t>
646 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
648 static _GLIBCXX_CONSTEXPR wchar_t
649 min() throw() { return __glibcxx_min (wchar_t); }
651 static _GLIBCXX_CONSTEXPR wchar_t
652 max() throw() { return __glibcxx_max (wchar_t); }
654 #ifdef __GXX_EXPERIMENTAL_CXX0X__
655 static constexpr wchar_t
656 lowest() throw() { return min(); }
659 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (wchar_t);
660 static _GLIBCXX_USE_CONSTEXPR int digits10
661 = __glibcxx_digits10 (wchar_t);
662 #ifdef __GXX_EXPERIMENTAL_CXX0X__
663 static constexpr int max_digits10 = 0;
665 static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (wchar_t);
666 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
667 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
668 static _GLIBCXX_USE_CONSTEXPR int radix = 2;
670 static _GLIBCXX_CONSTEXPR wchar_t
671 epsilon() throw() { return 0; }
673 static _GLIBCXX_CONSTEXPR wchar_t
674 round_error() throw() { return 0; }
676 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
677 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
678 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
679 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
681 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
682 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
683 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
684 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
686 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
688 static _GLIBCXX_CONSTEXPR wchar_t
689 infinity() throw() { return wchar_t(); }
691 static _GLIBCXX_CONSTEXPR wchar_t
692 quiet_NaN() throw() { return wchar_t(); }
694 static _GLIBCXX_CONSTEXPR wchar_t
695 signaling_NaN() throw() { return wchar_t(); }
697 static _GLIBCXX_CONSTEXPR wchar_t
698 denorm_min() throw() { return wchar_t(); }
700 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
701 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
702 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
704 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
705 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
706 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
710 #ifdef __GXX_EXPERIMENTAL_CXX0X__
711 /// numeric_limits<char16_t> specialization.
713 struct numeric_limits<char16_t>
715 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
717 static _GLIBCXX_CONSTEXPR char16_t
718 min() throw() { return __glibcxx_min (char16_t); }
720 static _GLIBCXX_CONSTEXPR char16_t
721 max() throw() { return __glibcxx_max (char16_t); }
723 #ifdef __GXX_EXPERIMENTAL_CXX0X__
724 static constexpr char16_t
725 lowest() throw() { return min(); }
728 static _GLIBCXX_USE_CONSTEXPR int digits
729 = __glibcxx_digits (char16_t);
730 static _GLIBCXX_USE_CONSTEXPR int digits10
731 = __glibcxx_digits10 (char16_t);
732 #ifdef __GXX_EXPERIMENTAL_CXX0X__
733 static constexpr int max_digits10 = 0;
735 static _GLIBCXX_USE_CONSTEXPR bool is_signed
736 = __glibcxx_signed (char16_t);
737 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
738 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
739 static _GLIBCXX_USE_CONSTEXPR int radix = 2;
741 static _GLIBCXX_CONSTEXPR char16_t
742 epsilon() throw() { return 0; }
744 static _GLIBCXX_CONSTEXPR char16_t
745 round_error() throw() { return 0; }
747 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
748 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
749 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
750 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
752 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
753 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
754 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
755 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
757 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
759 static _GLIBCXX_CONSTEXPR char16_t
760 infinity() throw() { return char16_t(); }
762 static _GLIBCXX_CONSTEXPR char16_t
763 quiet_NaN() throw() { return char16_t(); }
765 static _GLIBCXX_CONSTEXPR char16_t
766 signaling_NaN() throw() { return char16_t(); }
768 static _GLIBCXX_CONSTEXPR char16_t
769 denorm_min() throw() { return char16_t(); }
771 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
772 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
773 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
775 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
776 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
777 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
781 /// numeric_limits<char32_t> specialization.
783 struct numeric_limits<char32_t>
785 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
787 static _GLIBCXX_CONSTEXPR char32_t
788 min() throw() { return __glibcxx_min (char32_t); }
790 static _GLIBCXX_CONSTEXPR char32_t
791 max() throw() { return __glibcxx_max (char32_t); }
793 #ifdef __GXX_EXPERIMENTAL_CXX0X__
794 static constexpr char32_t
795 lowest() throw() { return min(); }
798 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (char32_t);
799 static _GLIBCXX_USE_CONSTEXPR int digits10
800 = __glibcxx_digits10 (char32_t);
801 #ifdef __GXX_EXPERIMENTAL_CXX0X__
802 static constexpr int max_digits10 = 0;
804 static _GLIBCXX_USE_CONSTEXPR bool is_signed
805 = __glibcxx_signed (char32_t);
806 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
807 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
808 static _GLIBCXX_USE_CONSTEXPR int radix = 2;
810 static _GLIBCXX_CONSTEXPR char32_t
811 epsilon() throw() { return 0; }
813 static _GLIBCXX_CONSTEXPR char32_t
814 round_error() throw() { return 0; }
816 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
817 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
818 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
819 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
821 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
822 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
823 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
824 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
826 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
828 static _GLIBCXX_CONSTEXPR char32_t
829 infinity() throw() { return char32_t(); }
831 static _GLIBCXX_CONSTEXPR char32_t
832 quiet_NaN() throw() { return char32_t(); }
834 static _GLIBCXX_CONSTEXPR char32_t
835 signaling_NaN() throw() { return char32_t(); }
837 static _GLIBCXX_CONSTEXPR char32_t
838 denorm_min() throw() { return char32_t(); }
840 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
841 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
842 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
844 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
845 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
846 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
851 /// numeric_limits<short> specialization.
853 struct numeric_limits<short>
855 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
857 static _GLIBCXX_CONSTEXPR short
858 min() throw() { return -__SHRT_MAX__ - 1; }
860 static _GLIBCXX_CONSTEXPR short
861 max() throw() { return __SHRT_MAX__; }
863 #ifdef __GXX_EXPERIMENTAL_CXX0X__
864 static constexpr short
865 lowest() throw() { return min(); }
868 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (short);
869 static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (short);
870 #ifdef __GXX_EXPERIMENTAL_CXX0X__
871 static constexpr int max_digits10 = 0;
873 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
874 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
875 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
876 static _GLIBCXX_USE_CONSTEXPR int radix = 2;
878 static _GLIBCXX_CONSTEXPR short
879 epsilon() throw() { return 0; }
881 static _GLIBCXX_CONSTEXPR short
882 round_error() throw() { return 0; }
884 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
885 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
886 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
887 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
889 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
890 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
891 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
892 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
894 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
896 static _GLIBCXX_CONSTEXPR short
897 infinity() throw() { return short(); }
899 static _GLIBCXX_CONSTEXPR short
900 quiet_NaN() throw() { return short(); }
902 static _GLIBCXX_CONSTEXPR short
903 signaling_NaN() throw() { return short(); }
905 static _GLIBCXX_CONSTEXPR short
906 denorm_min() throw() { return short(); }
908 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
909 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
910 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
912 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
913 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
914 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
918 /// numeric_limits<unsigned short> specialization.
920 struct numeric_limits<unsigned short>
922 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
924 static _GLIBCXX_CONSTEXPR unsigned short
925 min() throw() { return 0; }
927 static _GLIBCXX_CONSTEXPR unsigned short
928 max() throw() { return __SHRT_MAX__ * 2U + 1; }
930 #ifdef __GXX_EXPERIMENTAL_CXX0X__
931 static constexpr unsigned short
932 lowest() throw() { return min(); }
935 static _GLIBCXX_USE_CONSTEXPR int digits
936 = __glibcxx_digits (unsigned short);
937 static _GLIBCXX_USE_CONSTEXPR int digits10
938 = __glibcxx_digits10 (unsigned short);
939 #ifdef __GXX_EXPERIMENTAL_CXX0X__
940 static constexpr int max_digits10 = 0;
942 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
943 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
944 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
945 static _GLIBCXX_USE_CONSTEXPR int radix = 2;
947 static _GLIBCXX_CONSTEXPR unsigned short
948 epsilon() throw() { return 0; }
950 static _GLIBCXX_CONSTEXPR unsigned short
951 round_error() throw() { return 0; }
953 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
954 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
955 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
956 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
958 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
959 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
960 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
961 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
963 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
965 static _GLIBCXX_CONSTEXPR unsigned short
966 infinity() throw() { return static_cast<unsigned short>(0); }
968 static _GLIBCXX_CONSTEXPR unsigned short
969 quiet_NaN() throw() { return static_cast<unsigned short>(0); }
971 static _GLIBCXX_CONSTEXPR unsigned short
972 signaling_NaN() throw() { return static_cast<unsigned short>(0); }
974 static _GLIBCXX_CONSTEXPR unsigned short
975 denorm_min() throw() { return static_cast<unsigned short>(0); }
977 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
978 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
979 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
981 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
982 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
983 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
987 /// numeric_limits<int> specialization.
989 struct numeric_limits<int>
991 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
993 static _GLIBCXX_CONSTEXPR int
994 min() throw() { return -__INT_MAX__ - 1; }
996 static _GLIBCXX_CONSTEXPR int
997 max() throw() { return __INT_MAX__; }
999 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1000 static constexpr int
1001 lowest() throw() { return min(); }
1004 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (int);
1005 static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (int);
1006 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1007 static constexpr int max_digits10 = 0;
1009 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1010 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1011 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1012 static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1014 static _GLIBCXX_CONSTEXPR int
1015 epsilon() throw() { return 0; }
1017 static _GLIBCXX_CONSTEXPR int
1018 round_error() throw() { return 0; }
1020 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1021 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1022 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1023 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1025 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1026 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1027 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1028 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1030 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1032 static _GLIBCXX_CONSTEXPR int
1033 infinity() throw() { return static_cast<int>(0); }
1035 static _GLIBCXX_CONSTEXPR int
1036 quiet_NaN() throw() { return static_cast<int>(0); }
1038 static _GLIBCXX_CONSTEXPR int
1039 signaling_NaN() throw() { return static_cast<int>(0); }
1041 static _GLIBCXX_CONSTEXPR int
1042 denorm_min() throw() { return static_cast<int>(0); }
1044 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1045 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1046 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1048 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1049 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1050 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1051 = round_toward_zero;
1054 /// numeric_limits<unsigned int> specialization.
1056 struct numeric_limits<unsigned int>
1058 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1060 static _GLIBCXX_CONSTEXPR unsigned int
1061 min() throw() { return 0; }
1063 static _GLIBCXX_CONSTEXPR unsigned int
1064 max() throw() { return __INT_MAX__ * 2U + 1; }
1066 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1067 static constexpr unsigned int
1068 lowest() throw() { return min(); }
1071 static _GLIBCXX_USE_CONSTEXPR int digits
1072 = __glibcxx_digits (unsigned int);
1073 static _GLIBCXX_USE_CONSTEXPR int digits10
1074 = __glibcxx_digits10 (unsigned int);
1075 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1076 static constexpr int max_digits10 = 0;
1078 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
1079 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1080 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1081 static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1083 static _GLIBCXX_CONSTEXPR unsigned int
1084 epsilon() throw() { return 0; }
1086 static _GLIBCXX_CONSTEXPR unsigned int
1087 round_error() throw() { return 0; }
1089 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1090 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1091 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1092 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1094 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1095 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1096 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1097 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1099 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1101 static _GLIBCXX_CONSTEXPR unsigned int
1102 infinity() throw() { return static_cast<unsigned int>(0); }
1104 static _GLIBCXX_CONSTEXPR unsigned int
1105 quiet_NaN() throw() { return static_cast<unsigned int>(0); }
1107 static _GLIBCXX_CONSTEXPR unsigned int
1108 signaling_NaN() throw() { return static_cast<unsigned int>(0); }
1110 static _GLIBCXX_CONSTEXPR unsigned int
1111 denorm_min() throw() { return static_cast<unsigned int>(0); }
1113 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1114 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1115 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1117 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1118 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1119 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1120 = round_toward_zero;
1123 /// numeric_limits<long> specialization.
1125 struct numeric_limits<long>
1127 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1129 static _GLIBCXX_CONSTEXPR long
1130 min() throw() { return -__LONG_MAX__ - 1; }
1132 static _GLIBCXX_CONSTEXPR long
1133 max() throw() { return __LONG_MAX__; }
1135 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1136 static constexpr long
1137 lowest() throw() { return min(); }
1140 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (long);
1141 static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (long);
1142 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1143 static constexpr int max_digits10 = 0;
1145 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1146 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1147 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1148 static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1150 static _GLIBCXX_CONSTEXPR long
1151 epsilon() throw() { return 0; }
1153 static _GLIBCXX_CONSTEXPR long
1154 round_error() throw() { return 0; }
1156 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1157 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1158 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1159 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1161 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1162 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1163 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1164 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1166 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1168 static _GLIBCXX_CONSTEXPR long
1169 infinity() throw() { return static_cast<long>(0); }
1171 static _GLIBCXX_CONSTEXPR long
1172 quiet_NaN() throw() { return static_cast<long>(0); }
1174 static _GLIBCXX_CONSTEXPR long
1175 signaling_NaN() throw() { return static_cast<long>(0); }
1177 static _GLIBCXX_CONSTEXPR long
1178 denorm_min() throw() { return static_cast<long>(0); }
1180 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1181 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1182 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1184 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1185 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1186 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1187 = round_toward_zero;
1190 /// numeric_limits<unsigned long> specialization.
1192 struct numeric_limits<unsigned long>
1194 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1196 static _GLIBCXX_CONSTEXPR unsigned long
1197 min() throw() { return 0; }
1199 static _GLIBCXX_CONSTEXPR unsigned long
1200 max() throw() { return __LONG_MAX__ * 2UL + 1; }
1202 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1203 static constexpr unsigned long
1204 lowest() throw() { return min(); }
1207 static _GLIBCXX_USE_CONSTEXPR int digits
1208 = __glibcxx_digits (unsigned long);
1209 static _GLIBCXX_USE_CONSTEXPR int digits10
1210 = __glibcxx_digits10 (unsigned long);
1211 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1212 static constexpr int max_digits10 = 0;
1214 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
1215 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1216 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1217 static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1219 static _GLIBCXX_CONSTEXPR unsigned long
1220 epsilon() throw() { return 0; }
1222 static _GLIBCXX_CONSTEXPR unsigned long
1223 round_error() throw() { return 0; }
1225 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1226 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1227 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1228 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1230 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1231 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1232 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1233 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1235 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1237 static _GLIBCXX_CONSTEXPR unsigned long
1238 infinity() throw() { return static_cast<unsigned long>(0); }
1240 static _GLIBCXX_CONSTEXPR unsigned long
1241 quiet_NaN() throw() { return static_cast<unsigned long>(0); }
1243 static _GLIBCXX_CONSTEXPR unsigned long
1244 signaling_NaN() throw() { return static_cast<unsigned long>(0); }
1246 static _GLIBCXX_CONSTEXPR unsigned long
1247 denorm_min() throw() { return static_cast<unsigned long>(0); }
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;
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;
1259 /// numeric_limits<long long> specialization.
1261 struct numeric_limits<long long>
1263 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1265 static _GLIBCXX_CONSTEXPR long long
1266 min() throw() { return -__LONG_LONG_MAX__ - 1; }
1268 static _GLIBCXX_CONSTEXPR long long
1269 max() throw() { return __LONG_LONG_MAX__; }
1271 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1272 static constexpr long long
1273 lowest() throw() { return min(); }
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 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1281 static constexpr int max_digits10 = 0;
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;
1288 static _GLIBCXX_CONSTEXPR long long
1289 epsilon() throw() { return 0; }
1291 static _GLIBCXX_CONSTEXPR long long
1292 round_error() throw() { return 0; }
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;
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
1304 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1306 static _GLIBCXX_CONSTEXPR long long
1307 infinity() throw() { return static_cast<long long>(0); }
1309 static _GLIBCXX_CONSTEXPR long long
1310 quiet_NaN() throw() { return static_cast<long long>(0); }
1312 static _GLIBCXX_CONSTEXPR long long
1313 signaling_NaN() throw() { return static_cast<long long>(0); }
1315 static _GLIBCXX_CONSTEXPR long long
1316 denorm_min() throw() { return static_cast<long long>(0); }
1318 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1319 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1320 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1322 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1323 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1324 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1325 = round_toward_zero;
1328 /// numeric_limits<unsigned long long> specialization.
1330 struct numeric_limits<unsigned long long>
1332 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1334 static _GLIBCXX_CONSTEXPR unsigned long long
1335 min() throw() { return 0; }
1337 static _GLIBCXX_CONSTEXPR unsigned long long
1338 max() throw() { return __LONG_LONG_MAX__ * 2ULL + 1; }
1340 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1341 static constexpr unsigned long long
1342 lowest() throw() { return min(); }
1345 static _GLIBCXX_USE_CONSTEXPR int digits
1346 = __glibcxx_digits (unsigned long long);
1347 static _GLIBCXX_USE_CONSTEXPR int digits10
1348 = __glibcxx_digits10 (unsigned long long);
1349 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1350 static constexpr int max_digits10 = 0;
1352 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
1353 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1354 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1355 static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1357 static _GLIBCXX_CONSTEXPR unsigned long long
1358 epsilon() throw() { return 0; }
1360 static _GLIBCXX_CONSTEXPR unsigned long long
1361 round_error() throw() { return 0; }
1363 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1364 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1365 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1366 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1368 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1369 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1370 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1371 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1373 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1375 static _GLIBCXX_CONSTEXPR unsigned long long
1376 infinity() throw() { return static_cast<unsigned long long>(0); }
1378 static _GLIBCXX_CONSTEXPR unsigned long long
1379 quiet_NaN() throw() { return static_cast<unsigned long long>(0); }
1381 static _GLIBCXX_CONSTEXPR unsigned long long
1382 signaling_NaN() throw() { return static_cast<unsigned long long>(0); }
1384 static _GLIBCXX_CONSTEXPR unsigned long long
1385 denorm_min() throw() { return static_cast<unsigned long long>(0); }
1387 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1388 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1389 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1391 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1392 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1393 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1394 = round_toward_zero;
1397 /// numeric_limits<float> specialization.
1399 struct numeric_limits<float>
1401 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1403 static _GLIBCXX_CONSTEXPR float
1404 min() throw() { return __FLT_MIN__; }
1406 static _GLIBCXX_CONSTEXPR float
1407 max() throw() { return __FLT_MAX__; }
1409 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1410 static constexpr float
1411 lowest() throw() { return -__FLT_MAX__; }
1414 static _GLIBCXX_USE_CONSTEXPR int digits = __FLT_MANT_DIG__;
1415 static _GLIBCXX_USE_CONSTEXPR int digits10 = __FLT_DIG__;
1416 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1417 static constexpr int max_digits10
1418 = __glibcxx_max_digits10 (__FLT_MANT_DIG__);
1420 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1421 static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
1422 static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
1423 static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
1425 static _GLIBCXX_CONSTEXPR float
1426 epsilon() throw() { return __FLT_EPSILON__; }
1428 static _GLIBCXX_CONSTEXPR float
1429 round_error() throw() { return 0.5F; }
1431 static _GLIBCXX_USE_CONSTEXPR int min_exponent = __FLT_MIN_EXP__;
1432 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __FLT_MIN_10_EXP__;
1433 static _GLIBCXX_USE_CONSTEXPR int max_exponent = __FLT_MAX_EXP__;
1434 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __FLT_MAX_10_EXP__;
1436 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __FLT_HAS_INFINITY__;
1437 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __FLT_HAS_QUIET_NAN__;
1438 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN;
1439 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1440 = bool(__FLT_HAS_DENORM__) ? denorm_present : denorm_absent;
1441 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
1442 = __glibcxx_float_has_denorm_loss;
1444 static _GLIBCXX_CONSTEXPR float
1445 infinity() throw() { return __builtin_huge_valf (); }
1447 static _GLIBCXX_CONSTEXPR float
1448 quiet_NaN() throw() { return __builtin_nanf (""); }
1450 static _GLIBCXX_CONSTEXPR float
1451 signaling_NaN() throw() { return __builtin_nansf (""); }
1453 static _GLIBCXX_CONSTEXPR float
1454 denorm_min() throw() { return __FLT_DENORM_MIN__; }
1456 static _GLIBCXX_USE_CONSTEXPR bool is_iec559
1457 = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
1458 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1459 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1461 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_float_traps;
1462 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before
1463 = __glibcxx_float_tinyness_before;
1464 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1468 #undef __glibcxx_float_has_denorm_loss
1469 #undef __glibcxx_float_traps
1470 #undef __glibcxx_float_tinyness_before
1472 /// numeric_limits<double> specialization.
1474 struct numeric_limits<double>
1476 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1478 static _GLIBCXX_CONSTEXPR double
1479 min() throw() { return __DBL_MIN__; }
1481 static _GLIBCXX_CONSTEXPR double
1482 max() throw() { return __DBL_MAX__; }
1484 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1485 static constexpr double
1486 lowest() throw() { return -__DBL_MAX__; }
1489 static _GLIBCXX_USE_CONSTEXPR int digits = __DBL_MANT_DIG__;
1490 static _GLIBCXX_USE_CONSTEXPR int digits10 = __DBL_DIG__;
1491 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1492 static constexpr int max_digits10
1493 = __glibcxx_max_digits10 (__DBL_MANT_DIG__);
1495 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1496 static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
1497 static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
1498 static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
1500 static _GLIBCXX_CONSTEXPR double
1501 epsilon() throw() { return __DBL_EPSILON__; }
1503 static _GLIBCXX_CONSTEXPR double
1504 round_error() throw() { return 0.5; }
1506 static _GLIBCXX_USE_CONSTEXPR int min_exponent = __DBL_MIN_EXP__;
1507 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __DBL_MIN_10_EXP__;
1508 static _GLIBCXX_USE_CONSTEXPR int max_exponent = __DBL_MAX_EXP__;
1509 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __DBL_MAX_10_EXP__;
1511 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __DBL_HAS_INFINITY__;
1512 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __DBL_HAS_QUIET_NAN__;
1513 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN;
1514 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1515 = bool(__DBL_HAS_DENORM__) ? denorm_present : denorm_absent;
1516 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
1517 = __glibcxx_double_has_denorm_loss;
1519 static _GLIBCXX_CONSTEXPR double
1520 infinity() throw() { return __builtin_huge_val(); }
1522 static _GLIBCXX_CONSTEXPR double
1523 quiet_NaN() throw() { return __builtin_nan (""); }
1525 static _GLIBCXX_CONSTEXPR double
1526 signaling_NaN() throw() { return __builtin_nans (""); }
1528 static _GLIBCXX_CONSTEXPR double
1529 denorm_min() throw() { return __DBL_DENORM_MIN__; }
1531 static _GLIBCXX_USE_CONSTEXPR bool is_iec559
1532 = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
1533 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1534 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1536 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_double_traps;
1537 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before
1538 = __glibcxx_double_tinyness_before;
1539 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1543 #undef __glibcxx_double_has_denorm_loss
1544 #undef __glibcxx_double_traps
1545 #undef __glibcxx_double_tinyness_before
1547 /// numeric_limits<long double> specialization.
1549 struct numeric_limits<long double>
1551 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1553 static _GLIBCXX_CONSTEXPR long double
1554 min() throw() { return __LDBL_MIN__; }
1556 static _GLIBCXX_CONSTEXPR long double
1557 max() throw() { return __LDBL_MAX__; }
1559 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1560 static constexpr long double
1561 lowest() throw() { return -__LDBL_MAX__; }
1564 static _GLIBCXX_USE_CONSTEXPR int digits = __LDBL_MANT_DIG__;
1565 static _GLIBCXX_USE_CONSTEXPR int digits10 = __LDBL_DIG__;
1566 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1567 static _GLIBCXX_USE_CONSTEXPR int max_digits10
1568 = __glibcxx_max_digits10 (__LDBL_MANT_DIG__);
1570 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1571 static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
1572 static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
1573 static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
1575 static _GLIBCXX_CONSTEXPR long double
1576 epsilon() throw() { return __LDBL_EPSILON__; }
1578 static _GLIBCXX_CONSTEXPR long double
1579 round_error() throw() { return 0.5L; }
1581 static _GLIBCXX_USE_CONSTEXPR int min_exponent = __LDBL_MIN_EXP__;
1582 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __LDBL_MIN_10_EXP__;
1583 static _GLIBCXX_USE_CONSTEXPR int max_exponent = __LDBL_MAX_EXP__;
1584 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __LDBL_MAX_10_EXP__;
1586 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __LDBL_HAS_INFINITY__;
1587 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __LDBL_HAS_QUIET_NAN__;
1588 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN;
1589 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1590 = bool(__LDBL_HAS_DENORM__) ? denorm_present : denorm_absent;
1591 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
1592 = __glibcxx_long_double_has_denorm_loss;
1594 static _GLIBCXX_CONSTEXPR long double
1595 infinity() throw() { return __builtin_huge_vall (); }
1597 static _GLIBCXX_CONSTEXPR long double
1598 quiet_NaN() throw() { return __builtin_nanl (""); }
1600 static _GLIBCXX_CONSTEXPR long double
1601 signaling_NaN() throw() { return __builtin_nansl (""); }
1603 static _GLIBCXX_CONSTEXPR long double
1604 denorm_min() throw() { return __LDBL_DENORM_MIN__; }
1606 static _GLIBCXX_USE_CONSTEXPR bool is_iec559
1607 = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
1608 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1609 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1611 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_long_double_traps;
1612 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before =
1613 __glibcxx_long_double_tinyness_before;
1614 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style =
1618 #undef __glibcxx_long_double_has_denorm_loss
1619 #undef __glibcxx_long_double_traps
1620 #undef __glibcxx_long_double_tinyness_before
1622 _GLIBCXX_END_NAMESPACE_VERSION
1625 #undef __glibcxx_signed
1626 #undef __glibcxx_min
1627 #undef __glibcxx_max
1628 #undef __glibcxx_digits
1629 #undef __glibcxx_digits10
1630 #undef __glibcxx_max_digits10
1632 #endif // _GLIBCXX_NUMERIC_LIMITS