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