STLdoc
STLdocumentation
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Macros | Functions
limits File Reference
#include <bits/c++config.h>

Macros

#define _GLIBCXX_NUMERIC_LIMITS   1
 
#define __glibcxx_integral_traps   true
 
#define __glibcxx_float_has_denorm_loss   false
 
#define __glibcxx_float_traps   false
 
#define __glibcxx_float_tinyness_before   false
 
#define __glibcxx_double_has_denorm_loss   false
 
#define __glibcxx_double_traps   false
 
#define __glibcxx_double_tinyness_before   false
 
#define __glibcxx_long_double_has_denorm_loss   false
 
#define __glibcxx_long_double_traps   false
 
#define __glibcxx_long_double_tinyness_before   false
 
#define __glibcxx_signed(T)   ((T)(-1) < 0)
 
#define __glibcxx_min(T)   (__glibcxx_signed (T) ? -__glibcxx_max (T) - 1 : (T)0)
 
#define __glibcxx_max(T)
 
#define __glibcxx_digits(T)   (sizeof(T) * __CHAR_BIT__ - __glibcxx_signed (T))
 
#define __glibcxx_digits10(T)   (__glibcxx_digits (T) * 643L / 2136)
 
#define __glibcxx_max_digits10(T)   (2 + (T) * 643L / 2136)
 

Functions

namespace std _GLIBCXX_VISIBILITY (default)
 

Macro Definition Documentation

#define __glibcxx_digits (   T)    (sizeof(T) * __CHAR_BIT__ - __glibcxx_signed (T))
#define __glibcxx_digits10 (   T)    (__glibcxx_digits (T) * 643L / 2136)
#define __glibcxx_double_has_denorm_loss   false
#define __glibcxx_double_tinyness_before   false
#define __glibcxx_double_traps   false
#define __glibcxx_float_has_denorm_loss   false
#define __glibcxx_float_tinyness_before   false
#define __glibcxx_float_traps   false
#define __glibcxx_integral_traps   true
#define __glibcxx_long_double_has_denorm_loss   false
#define __glibcxx_long_double_tinyness_before   false
#define __glibcxx_long_double_traps   false
#define __glibcxx_max (   T)
Value:
(__glibcxx_signed (T) ? \
(((((T)1 << (__glibcxx_digits (T) - 1)) - 1) << 1) + 1) : ~(T)0)
__glibcxx_signed
#define __glibcxx_signed(T)
Definition: limits:128
__glibcxx_digits
#define __glibcxx_digits(T)
Definition: limits:137
#define __glibcxx_max_digits10 (   T)    (2 + (T) * 643L / 2136)
#define __glibcxx_min (   T)    (__glibcxx_signed (T) ? -__glibcxx_max (T) - 1 : (T)0)
#define __glibcxx_signed (   T)    ((T)(-1) < 0)
#define _GLIBCXX_NUMERIC_LIMITS   1

Function Documentation

namespace std _GLIBCXX_VISIBILITY ( default  )

Describes the rounding style for floating-point types.

This is used in the std::numeric_limits class.

Intermediate.

To zero.

To the nearest representable value.

To infinity.

To negative infinity.

Describes the denormalization for floating-point types.

These values represent the presence or absence of a variable number of exponent bits. This type is used in the std::numeric_limits class.

Indeterminate at compile time whether denormalized values are allowed.

The type does not allow denormalized values.

The type allows denormalized values.

Part of std::numeric_limits.

The static const members are usable as integral constant expressions.

Note
This is a separate class for purposes of efficiency; you should only access these members as part of an instantiation of the std::numeric_limits class.

This will be true for all fundamental types (which have specializations), and false for everything else. 

The number of @c radix digits that be represented without change:  for

integer types, the number of non-sign bits in the mantissa; for floating types, the number of radix digits in the mantissa.

The number of base 10 digits that can be represented without change.

True if the type is signed.

True if the type is integer. 

True if the type uses an exact representation. All integer types are

exact, but not all exact types are integer. For example, rational and fixed-exponent representations are exact but not integer. 

For integer types, specifies the base of the representation.  For

floating types, specifies the base of the exponent representation. 

The minimum negative integer such that @c radix raised to the power of

(one less than that integer) is a normalized floating point number. 

The minimum negative integer such that 10 raised to that power is in

the range of normalized floating point numbers. 

The maximum positive integer such that @c radix raised to the power of

(one less than that integer) is a representable finite floating point number. 

The maximum positive integer such that 10 raised to that power is in

the range of representable finite floating point numbers.

True if the type has a representation for positive infinity. 

True if the type has a representation for a quiet (non-signaling)

Not a Number. 

True if the type has a representation for a signaling

Not a Number.

See std::float_denorm_style for more information. 

True if loss of accuracy is detected as a denormalization loss,

rather than as an inexact result. 

True if-and-only-if the type adheres to the IEC 559 standard, also

known as IEEE 754. (Only makes sense for floating point types.) 

True if the set of values representable by the type is

finite. All built-in types are bounded, this member would be false for arbitrary precision types. 

True if the type is @e modulo. A type is modulo if, for any

operation involving +, -, or * on values of that type whose result would fall outside the range [min(),max()], the value returned differs from the true value by an integer multiple of max() - min() + 1. On most machines, this is false for floating types, true for unsigned integers, and true for signed integers. See PR22200 about signed integers.

True if trapping is implemented for this type.

True if tininess is detected before rounding. (see IEC 559) 

See std::float_round_style for more information.  This is only

meaningful for floating types; integer types will all be round_toward_zero.

Properties of fundamental types.

This class allows a program to obtain information about the representation of a fundamental type on a given platform. For non-fundamental types, the functions will return 0 and the data members will all be false.

_GLIBCXX_RESOLVE_LIB_DEFECTS: DRs 201 and 184 (hi Gaby!) are noted, but not incorporated in this documented (yet).

The minimum finite value, or for floating types with denormalization, the minimum positive normalized value.

The maximum finite value. 

The @e machine @e epsilon:  the difference between 1 and the least

value greater than 1 that is representable.

The maximum rounding error measurement (see LIA-1).

The representation of positive infinity, if has_infinity. 

The representation of a quiet Not a Number,

if has_quiet_NaN. 

The representation of a signaling Not a Number, if

has_signaling_NaN. 

The minimum positive denormalized value.  For types where

has_denorm is false, this is the minimum positive normalized value.

numeric_limits<bool> specialization.

numeric_limits<char> specialization.

numeric_limits<signed char> specialization.

numeric_limits<unsigned char> specialization.

numeric_limits<wchar_t> specialization.

numeric_limits<short> specialization.

numeric_limits<unsigned short> specialization.

numeric_limits<int> specialization.

numeric_limits<unsigned int> specialization.

numeric_limits<long> specialization.

numeric_limits<unsigned long> specialization.

numeric_limits<long long> specialization.

numeric_limits<unsigned long long> specialization.

numeric_limits<float> specialization.

numeric_limits<double> specialization.

numeric_limits<long double> specialization.

148 {
149 _GLIBCXX_BEGIN_NAMESPACE_VERSION
150 
156  enum float_round_style
157  {
158  round_indeterminate = -1,
159  round_toward_zero = 0,
160  round_to_nearest = 1,
161  round_toward_infinity = 2,
162  round_toward_neg_infinity = 3
163  };
164 
171  enum float_denorm_style
172  {
174  denorm_indeterminate = -1,
176  denorm_absent = 0,
178  denorm_present = 1
179  };
180 
191  struct __numeric_limits_base
192  {
195  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = false;
196 
200  static _GLIBCXX_USE_CONSTEXPR int digits = 0;
201 
203  static _GLIBCXX_USE_CONSTEXPR int digits10 = 0;
204 
205 #if __cplusplus >= 201103L
206 
208  static constexpr int max_digits10 = 0;
209 #endif
210 
212  static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
213 
215  static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
216 
220  static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
221 
224  static _GLIBCXX_USE_CONSTEXPR int radix = 0;
225 
228  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
229 
232  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
233 
237  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
238 
241  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
242 
244  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
245 
248  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
249 
252  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
253 
255  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent;
256 
259  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
260 
263  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
264 
268  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = false;
269 
277  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
278 
280  static _GLIBCXX_USE_CONSTEXPR bool traps = false;
281 
283  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
284 
288  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style =
289  round_toward_zero;
290  };
291 
303  template<typename _Tp>
304  struct numeric_limits : public __numeric_limits_base
305  {
308  static _GLIBCXX_CONSTEXPR _Tp
309  min() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
310 
312  static _GLIBCXX_CONSTEXPR _Tp
313  max() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
314 
315 #if __cplusplus >= 201103L
316 
318  static constexpr _Tp
319  lowest() noexcept { return _Tp(); }
320 #endif
321 
324  static _GLIBCXX_CONSTEXPR _Tp
325  epsilon() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
326 
328  static _GLIBCXX_CONSTEXPR _Tp
329  round_error() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
330 
332  static _GLIBCXX_CONSTEXPR _Tp
333  infinity() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
334 
337  static _GLIBCXX_CONSTEXPR _Tp
338  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
339 
342  static _GLIBCXX_CONSTEXPR _Tp
343  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
344 
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 
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 
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 
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 
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 
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  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 
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 
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 
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 
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 
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 
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 
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 
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 
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  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 
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 
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 
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 
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
__glibcxx_max_digits10
#define __glibcxx_max_digits10(T)
Definition: limits:144
__glibcxx_digits10
#define __glibcxx_digits10(T)
Definition: limits:141
__glibcxx_float_traps
#define __glibcxx_float_traps
Definition: limits:92
__glibcxx_double_traps
#define __glibcxx_double_traps
Definition: limits:106
bool
#define bool
Definition: stdbool.h:33
__glibcxx_double_has_denorm_loss
#define __glibcxx_double_has_denorm_loss
Definition: limits:103
__glibcxx_long_double_traps
#define __glibcxx_long_double_traps
Definition: limits:120
__gnu_parallel::min
const _Tp & min(const _Tp &__a, const _Tp &__b)
Equivalent to std::min.
Definition: base.h:144
__glibcxx_long_double_has_denorm_loss
#define __glibcxx_long_double_has_denorm_loss
Definition: limits:117
__glibcxx_long_double_tinyness_before
#define __glibcxx_long_double_tinyness_before
Definition: limits:123
__glibcxx_max
#define __glibcxx_max(T)
Definition: limits:133
__glibcxx_float_tinyness_before
#define __glibcxx_float_tinyness_before
Definition: limits:95
__gnu_parallel::max
const _Tp & max(const _Tp &__a, const _Tp &__b)
Equivalent to std::max.
Definition: base.h:150
wchar_t
__WCHAR_TYPE__ wchar_t
Definition: stddef.h:324
__glibcxx_signed
#define __glibcxx_signed(T)
Definition: limits:128
__glibcxx_min
#define __glibcxx_min(T)
Definition: limits:130
__glibcxx_digits
#define __glibcxx_digits(T)
Definition: limits:137
__glibcxx_integral_traps
#define __glibcxx_integral_traps
Definition: limits:80
__glibcxx_double_tinyness_before
#define __glibcxx_double_tinyness_before
Definition: limits:109
__glibcxx_float_has_denorm_loss
#define __glibcxx_float_has_denorm_loss
Definition: limits:89
Generated on Sat Jul 22 2017 14:42:22 for STLdoc by   doxygen 1.8.6