libstdc++
limits
Go to the documentation of this file.
1 // The template and inlines for the numeric_limits classes. -*- C++ -*-
2 
3 // Copyright (C) 1999-2025 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 #ifdef _GLIBCXX_SYSHDR
41 #pragma GCC system_header
42 #endif
43 
44 #pragma GCC diagnostic push
45 #pragma GCC diagnostic ignored "-Wpedantic" // Q suffix
46 #pragma GCC diagnostic ignored "-Wlong-long"
47 #pragma GCC diagnostic ignored "-Wc++23-extensions"
48 
49 #include <bits/c++config.h>
50 
51 //
52 // The numeric_limits<> traits document implementation-defined aspects
53 // of fundamental arithmetic data types (integers and floating points).
54 // From Standard C++ point of view, there are 14 such types:
55 // * integers
56 // bool (1)
57 // char, signed char, unsigned char, wchar_t (4)
58 // short, unsigned short (2)
59 // int, unsigned (2)
60 // long, unsigned long (2)
61 //
62 // * floating points
63 // float (1)
64 // double (1)
65 // long double (1)
66 //
67 // GNU C++ understands (where supported by the host C-library)
68 // * integer
69 // long long, unsigned long long (2)
70 //
71 // which brings us to 16 fundamental arithmetic data types in GNU C++.
72 //
73 //
74 // Since a numeric_limits<> is a bit tricky to get right, we rely on
75 // an interface composed of macros which should be defined in config/os
76 // or config/cpu when they differ from the generic (read arbitrary)
77 // definitions given here.
78 //
79 
80 // These values can be overridden in the target configuration file.
81 // The default values are appropriate for many 32-bit targets.
82 
83 // GCC only intrinsically supports modulo integral types. The only remaining
84 // integral exceptional values is division by zero. Only targets that do not
85 // signal division by zero in some "hard to ignore" way should use false.
86 #ifndef __glibcxx_integral_traps
87 # define __glibcxx_integral_traps true
88 #endif
89 
90 // float
91 //
92 
93 // Default values. Should be overridden in configuration files if necessary.
94 
95 #ifndef __glibcxx_float_has_denorm_loss
96 # define __glibcxx_float_has_denorm_loss false
97 #endif
98 #ifndef __glibcxx_float_traps
99 # define __glibcxx_float_traps false
100 #endif
101 #ifndef __glibcxx_float_tinyness_before
102 # define __glibcxx_float_tinyness_before false
103 #endif
104 
105 // double
106 
107 // Default values. Should be overridden in configuration files if necessary.
108 
109 #ifndef __glibcxx_double_has_denorm_loss
110 # define __glibcxx_double_has_denorm_loss false
111 #endif
112 #ifndef __glibcxx_double_traps
113 # define __glibcxx_double_traps false
114 #endif
115 #ifndef __glibcxx_double_tinyness_before
116 # define __glibcxx_double_tinyness_before false
117 #endif
118 
119 // long double
120 
121 // Default values. Should be overridden in configuration files if necessary.
122 
123 #ifndef __glibcxx_long_double_has_denorm_loss
124 # define __glibcxx_long_double_has_denorm_loss false
125 #endif
126 #ifndef __glibcxx_long_double_traps
127 # define __glibcxx_long_double_traps false
128 #endif
129 #ifndef __glibcxx_long_double_tinyness_before
130 # define __glibcxx_long_double_tinyness_before false
131 #endif
132 
133 // You should not need to define any macros below this point.
134 
135 #define __glibcxx_signed_b(T,B) ((T)(-1) < 0)
136 
137 #define __glibcxx_min_b(T,B) \
138  (__glibcxx_signed_b (T,B) ? -__glibcxx_max_b (T,B) - 1 : (T)0)
139 
140 #define __glibcxx_max_b(T,B) \
141  (__glibcxx_signed_b (T,B) ? \
142  (((((T)1 << (__glibcxx_digits_b (T,B) - 1)) - 1) << 1) + 1) : ~(T)0)
143 
144 #define __glibcxx_digits_b(T,B) \
145  (B - __glibcxx_signed_b (T,B))
146 
147 // The fraction 643/2136 approximates log10(2) to 7 significant digits.
148 #define __glibcxx_digits10_b(T,B) \
149  (__glibcxx_digits_b (T,B) * 643L / 2136)
150 
151 #define __glibcxx_signed(T) \
152  __glibcxx_signed_b (T, sizeof(T) * __CHAR_BIT__)
153 #define __glibcxx_min(T) \
154  __glibcxx_min_b (T, sizeof(T) * __CHAR_BIT__)
155 #define __glibcxx_max(T) \
156  __glibcxx_max_b (T, sizeof(T) * __CHAR_BIT__)
157 #define __glibcxx_digits(T) \
158  __glibcxx_digits_b (T, sizeof(T) * __CHAR_BIT__)
159 #define __glibcxx_digits10(T) \
160  __glibcxx_digits10_b (T, sizeof(T) * __CHAR_BIT__)
161 
162 #define __glibcxx_max_digits10(T) \
163  (2 + (T) * 643L / 2136)
164 
165 namespace std _GLIBCXX_VISIBILITY(default)
166 {
167 _GLIBCXX_BEGIN_NAMESPACE_VERSION
168 
169  /**
170  * @brief Describes the rounding style for floating-point types.
171  *
172  * This is used in the std::numeric_limits class.
173  */
174  enum float_round_style
175  {
176  round_indeterminate = -1, ///< Intermediate.
177  round_toward_zero = 0, ///< To zero.
178  round_to_nearest = 1, ///< To the nearest representable value.
179  round_toward_infinity = 2, ///< To infinity.
180  round_toward_neg_infinity = 3 ///< To negative infinity.
181  };
182 
183  /**
184  * @brief Describes the denormalization for floating-point types.
185  *
186  * These values represent the presence or absence of a variable number
187  * of exponent bits. This type is used in the std::numeric_limits class.
188  */
189  enum float_denorm_style
190  {
191  /// Indeterminate at compile time whether denormalized values are allowed.
192  denorm_indeterminate = -1,
193  /// The type does not allow denormalized values.
194  denorm_absent = 0,
195  /// The type allows denormalized values.
196  denorm_present = 1
197  };
198 
199  /**
200  * @brief Part of std::numeric_limits.
201  *
202  * The @c static @c const members are usable as integral constant
203  * expressions.
204  *
205  * @note This is a separate class for purposes of efficiency; you
206  * should only access these members as part of an instantiation
207  * of the std::numeric_limits class.
208  */
209  struct __numeric_limits_base
210  {
211  /** This will be true for all fundamental types (which have
212  specializations), and false for everything else. */
213  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = false;
214 
215  /** The number of @c radix digits that be represented without change: for
216  integer types, the number of non-sign bits in the mantissa; for
217  floating types, the number of @c radix digits in the mantissa. */
218  static _GLIBCXX_USE_CONSTEXPR int digits = 0;
219 
220  /** The number of base 10 digits that can be represented without change. */
221  static _GLIBCXX_USE_CONSTEXPR int digits10 = 0;
222 
223 #if __cplusplus >= 201103L
224  /** The number of base 10 digits required to ensure that values which
225  differ are always differentiated. */
226  static constexpr int max_digits10 = 0;
227 #endif
228 
229  /** True if the type is signed. */
230  static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
231 
232  /** True if the type is integer. */
233  static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
234 
235  /** True if the type uses an exact representation. All integer types are
236  exact, but not all exact types are integer. For example, rational and
237  fixed-exponent representations are exact but not integer. */
238  static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
239 
240  /** For integer types, specifies the base of the representation. For
241  floating types, specifies the base of the exponent representation. */
242  static _GLIBCXX_USE_CONSTEXPR int radix = 0;
243 
244  /** The minimum negative integer such that @c radix raised to the power of
245  (one less than that integer) is a normalized floating point number. */
246  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
247 
248  /** The minimum negative integer such that 10 raised to that power is in
249  the range of normalized floating point numbers. */
250  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
251 
252  /** The maximum positive integer such that @c radix raised to the power of
253  (one less than that integer) is a representable finite floating point
254  number. */
255  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
256 
257  /** The maximum positive integer such that 10 raised to that power is in
258  the range of representable finite floating point numbers. */
259  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
260 
261  /** True if the type has a representation for positive infinity. */
262  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
263 
264  /** True if the type has a representation for a quiet (non-signaling)
265  Not a Number. */
266  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
267 
268  /** True if the type has a representation for a signaling
269  Not a Number. */
270  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
271 
272  /** See std::float_denorm_style for more information. */
273  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent;
274 
275  /** True if loss of accuracy is detected as a denormalization loss,
276  rather than as an inexact result. */
277  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
278 
279  /** True if-and-only-if the type adheres to the IEC 559 standard, also
280  known as IEEE 754. (Only makes sense for floating point types.) */
281  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
282 
283  /** True if the set of values representable by the type is
284  finite. All built-in types are bounded, this member would be
285  false for arbitrary precision types. */
286  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = false;
287 
288  /** True if the type is @e modulo. A type is modulo if, for any
289  operation involving +, -, or * on values of that type whose
290  result would fall outside the range [min(),max()], the value
291  returned differs from the true value by an integer multiple of
292  max() - min() + 1. On most machines, this is false for floating
293  types, true for unsigned integers, and true for signed integers.
294  See PR22200 about signed integers. */
295  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
296 
297  /** True if trapping is implemented for this type. */
298  static _GLIBCXX_USE_CONSTEXPR bool traps = false;
299 
300  /** True if tininess is detected before rounding. (see IEC 559) */
301  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
302 
303  /** See std::float_round_style for more information. This is only
304  meaningful for floating types; integer types will all be
305  round_toward_zero. */
306  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style =
307  round_toward_zero;
308  };
309 
310  /**
311  * @brief Properties of fundamental types.
312  *
313  * This class allows a program to obtain information about the
314  * representation of a fundamental type on a given platform. For
315  * non-fundamental types, the functions will return 0 and the data
316  * members will all be @c false.
317  */
318  template<typename _Tp>
319  struct numeric_limits : public __numeric_limits_base
320  {
321  /** The minimum finite value, or for floating types with
322  denormalization, the minimum positive normalized value. */
323  static _GLIBCXX_CONSTEXPR _Tp
324  min() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
325 
326  /** The maximum finite value. */
327  static _GLIBCXX_CONSTEXPR _Tp
328  max() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
329 
330 #if __cplusplus >= 201103L
331  /** A finite value x such that there is no other finite value y
332  * where y < x. */
333  static constexpr _Tp
334  lowest() noexcept { return _Tp(); }
335 #endif
336 
337  /** The @e machine @e epsilon: the difference between 1 and the least
338  value greater than 1 that is representable. */
339  static _GLIBCXX_CONSTEXPR _Tp
340  epsilon() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
341 
342  /** The maximum rounding error measurement (see LIA-1). */
343  static _GLIBCXX_CONSTEXPR _Tp
344  round_error() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
345 
346  /** The representation of positive infinity, if @c has_infinity. */
347  static _GLIBCXX_CONSTEXPR _Tp
348  infinity() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
349 
350  /** The representation of a quiet Not a Number,
351  if @c has_quiet_NaN. */
352  static _GLIBCXX_CONSTEXPR _Tp
353  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
354 
355  /** The representation of a signaling Not a Number, if
356  @c has_signaling_NaN. */
357  static _GLIBCXX_CONSTEXPR _Tp
358  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
359 
360  /** The minimum positive denormalized value. For types where
361  @c has_denorm is false, this is the minimum positive normalized
362  value. */
363  static _GLIBCXX_CONSTEXPR _Tp
364  denorm_min() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
365  };
366 
367  // _GLIBCXX_RESOLVE_LIB_DEFECTS
368  // 559. numeric_limits<const T>
369 
370  template<typename _Tp>
371  struct numeric_limits<const _Tp>
372  : public numeric_limits<_Tp> { };
373 
374  template<typename _Tp>
375  struct numeric_limits<volatile _Tp>
376  : public numeric_limits<_Tp> { };
377 
378  template<typename _Tp>
379  struct numeric_limits<const volatile _Tp>
380  : public numeric_limits<_Tp> { };
381 
382  // Now there follow 16 explicit specializations. Yes, 16. Make sure
383  // you get the count right. (18 in C++11 mode, with char16_t and char32_t.)
384  // (+1 if char8_t is enabled.)
385 
386  // _GLIBCXX_RESOLVE_LIB_DEFECTS
387  // 184. numeric_limits<bool> wording problems
388 
389  /// numeric_limits<bool> specialization.
390  template<>
391  struct numeric_limits<bool>
392  {
393  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
394 
395  static _GLIBCXX_CONSTEXPR bool
396  min() _GLIBCXX_USE_NOEXCEPT { return false; }
397 
398  static _GLIBCXX_CONSTEXPR bool
399  max() _GLIBCXX_USE_NOEXCEPT { return true; }
400 
401 #if __cplusplus >= 201103L
402  static constexpr bool
403  lowest() noexcept { return min(); }
404 #endif
405  static _GLIBCXX_USE_CONSTEXPR int digits = 1;
406  static _GLIBCXX_USE_CONSTEXPR int digits10 = 0;
407 #if __cplusplus >= 201103L
408  static constexpr int max_digits10 = 0;
409 #endif
410  static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
411  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
412  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
413  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
414 
415  static _GLIBCXX_CONSTEXPR bool
416  epsilon() _GLIBCXX_USE_NOEXCEPT { return false; }
417 
418  static _GLIBCXX_CONSTEXPR bool
419  round_error() _GLIBCXX_USE_NOEXCEPT { return false; }
420 
421  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
422  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
423  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
424  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
425 
426  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
427  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
428  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
429  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
430  = denorm_absent;
431  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
432 
433  static _GLIBCXX_CONSTEXPR bool
434  infinity() _GLIBCXX_USE_NOEXCEPT { return false; }
435 
436  static _GLIBCXX_CONSTEXPR bool
437  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return false; }
438 
439  static _GLIBCXX_CONSTEXPR bool
440  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return false; }
441 
442  static _GLIBCXX_CONSTEXPR bool
443  denorm_min() _GLIBCXX_USE_NOEXCEPT { return false; }
444 
445  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
446  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
447  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
448 
449  // It is not clear what it means for a boolean type to trap.
450  // This is a DR on the LWG issue list. Here, I use integer
451  // promotion semantics.
452  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
453  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
454  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
455  = round_toward_zero;
456  };
457 
458  /// numeric_limits<char> specialization.
459  template<>
460  struct numeric_limits<char>
461  {
462  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
463 
464  static _GLIBCXX_CONSTEXPR char
465  min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min(char); }
466 
467  static _GLIBCXX_CONSTEXPR char
468  max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max(char); }
469 
470 #if __cplusplus >= 201103L
471  static constexpr char
472  lowest() noexcept { return min(); }
473 #endif
474 
475  static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (char);
476  static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (char);
477 #if __cplusplus >= 201103L
478  static constexpr int max_digits10 = 0;
479 #endif
480  static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (char);
481  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
482  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
483  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
484 
485  static _GLIBCXX_CONSTEXPR char
486  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
487 
488  static _GLIBCXX_CONSTEXPR char
489  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
490 
491  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
492  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
493  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
494  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
495 
496  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
497  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
498  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
499  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
500  = denorm_absent;
501  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
502 
503  static _GLIBCXX_CONSTEXPR
504  char infinity() _GLIBCXX_USE_NOEXCEPT { return char(); }
505 
506  static _GLIBCXX_CONSTEXPR char
507  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return char(); }
508 
509  static _GLIBCXX_CONSTEXPR char
510  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return char(); }
511 
512  static _GLIBCXX_CONSTEXPR char
513  denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<char>(0); }
514 
515  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
516  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
517  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = !is_signed;
518 
519  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
520  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
521  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
522  = round_toward_zero;
523  };
524 
525  /// numeric_limits<signed char> specialization.
526  template<>
527  struct numeric_limits<signed char>
528  {
529  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
530 
531  static _GLIBCXX_CONSTEXPR signed char
532  min() _GLIBCXX_USE_NOEXCEPT { return -__SCHAR_MAX__ - 1; }
533 
534  static _GLIBCXX_CONSTEXPR signed char
535  max() _GLIBCXX_USE_NOEXCEPT { return __SCHAR_MAX__; }
536 
537 #if __cplusplus >= 201103L
538  static constexpr signed char
539  lowest() noexcept { return min(); }
540 #endif
541 
542  static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (signed char);
543  static _GLIBCXX_USE_CONSTEXPR int digits10
544  = __glibcxx_digits10 (signed char);
545 #if __cplusplus >= 201103L
546  static constexpr int max_digits10 = 0;
547 #endif
548  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
549  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
550  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
551  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
552 
553  static _GLIBCXX_CONSTEXPR signed char
554  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
555 
556  static _GLIBCXX_CONSTEXPR signed char
557  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
558 
559  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
560  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
561  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
562  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
563 
564  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
565  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
566  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
567  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
568  = denorm_absent;
569  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
570 
571  static _GLIBCXX_CONSTEXPR signed char
572  infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<signed char>(0); }
573 
574  static _GLIBCXX_CONSTEXPR signed char
575  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<signed char>(0); }
576 
577  static _GLIBCXX_CONSTEXPR signed char
578  signaling_NaN() _GLIBCXX_USE_NOEXCEPT
579  { return static_cast<signed char>(0); }
580 
581  static _GLIBCXX_CONSTEXPR signed char
582  denorm_min() _GLIBCXX_USE_NOEXCEPT
583  { return static_cast<signed char>(0); }
584 
585  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
586  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
587  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
588 
589  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
590  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
591  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
592  = round_toward_zero;
593  };
594 
595  /// numeric_limits<unsigned char> specialization.
596  template<>
597  struct numeric_limits<unsigned char>
598  {
599  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
600 
601  static _GLIBCXX_CONSTEXPR unsigned char
602  min() _GLIBCXX_USE_NOEXCEPT { return 0; }
603 
604  static _GLIBCXX_CONSTEXPR unsigned char
605  max() _GLIBCXX_USE_NOEXCEPT { return __SCHAR_MAX__ * 2U + 1; }
606 
607 #if __cplusplus >= 201103L
608  static constexpr unsigned char
609  lowest() noexcept { return min(); }
610 #endif
611 
612  static _GLIBCXX_USE_CONSTEXPR int digits
613  = __glibcxx_digits (unsigned char);
614  static _GLIBCXX_USE_CONSTEXPR int digits10
615  = __glibcxx_digits10 (unsigned char);
616 #if __cplusplus >= 201103L
617  static constexpr int max_digits10 = 0;
618 #endif
619  static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
620  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
621  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
622  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
623 
624  static _GLIBCXX_CONSTEXPR unsigned char
625  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
626 
627  static _GLIBCXX_CONSTEXPR unsigned char
628  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
629 
630  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
631  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
632  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
633  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
634 
635  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
636  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
637  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
638  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
639  = denorm_absent;
640  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
641 
642  static _GLIBCXX_CONSTEXPR unsigned char
643  infinity() _GLIBCXX_USE_NOEXCEPT
644  { return static_cast<unsigned char>(0); }
645 
646  static _GLIBCXX_CONSTEXPR unsigned char
647  quiet_NaN() _GLIBCXX_USE_NOEXCEPT
648  { return static_cast<unsigned char>(0); }
649 
650  static _GLIBCXX_CONSTEXPR unsigned char
651  signaling_NaN() _GLIBCXX_USE_NOEXCEPT
652  { return static_cast<unsigned char>(0); }
653 
654  static _GLIBCXX_CONSTEXPR unsigned char
655  denorm_min() _GLIBCXX_USE_NOEXCEPT
656  { return static_cast<unsigned char>(0); }
657 
658  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
659  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
660  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
661 
662  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
663  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
664  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
665  = round_toward_zero;
666  };
667 
668  /// numeric_limits<wchar_t> specialization.
669  template<>
670  struct numeric_limits<wchar_t>
671  {
672  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
673 
674  static _GLIBCXX_CONSTEXPR wchar_t
675  min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min (wchar_t); }
676 
677  static _GLIBCXX_CONSTEXPR wchar_t
678  max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max (wchar_t); }
679 
680 #if __cplusplus >= 201103L
681  static constexpr wchar_t
682  lowest() noexcept { return min(); }
683 #endif
684 
685  static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (wchar_t);
686  static _GLIBCXX_USE_CONSTEXPR int digits10
687  = __glibcxx_digits10 (wchar_t);
688 #if __cplusplus >= 201103L
689  static constexpr int max_digits10 = 0;
690 #endif
691  static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (wchar_t);
692  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
693  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
694  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
695 
696  static _GLIBCXX_CONSTEXPR wchar_t
697  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
698 
699  static _GLIBCXX_CONSTEXPR wchar_t
700  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
701 
702  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
703  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
704  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
705  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
706 
707  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
708  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
709  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
710  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
711  = denorm_absent;
712  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
713 
714  static _GLIBCXX_CONSTEXPR wchar_t
715  infinity() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
716 
717  static _GLIBCXX_CONSTEXPR wchar_t
718  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
719 
720  static _GLIBCXX_CONSTEXPR wchar_t
721  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
722 
723  static _GLIBCXX_CONSTEXPR wchar_t
724  denorm_min() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
725 
726  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
727  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
728  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = !is_signed;
729 
730  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
731  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
732  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
733  = round_toward_zero;
734  };
735 
736 #if _GLIBCXX_USE_CHAR8_T
737  /// numeric_limits<char8_t> specialization.
738  template<>
739  struct numeric_limits<char8_t>
740  {
741  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
742 
743  static _GLIBCXX_CONSTEXPR char8_t
744  min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min (char8_t); }
745 
746  static _GLIBCXX_CONSTEXPR char8_t
747  max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max (char8_t); }
748 
749  static _GLIBCXX_CONSTEXPR char8_t
750  lowest() _GLIBCXX_USE_NOEXCEPT { return min(); }
751 
752  static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (char8_t);
753  static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (char8_t);
754  static _GLIBCXX_USE_CONSTEXPR int max_digits10 = 0;
755  static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (char8_t);
756  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
757  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
758  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
759 
760  static _GLIBCXX_CONSTEXPR char8_t
761  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
762 
763  static _GLIBCXX_CONSTEXPR char8_t
764  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
765 
766  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
767  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
768  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
769  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
770 
771  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
772  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
773  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
774  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
775  = denorm_absent;
776  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
777 
778  static _GLIBCXX_CONSTEXPR char8_t
779  infinity() _GLIBCXX_USE_NOEXCEPT { return char8_t(); }
780 
781  static _GLIBCXX_CONSTEXPR char8_t
782  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return char8_t(); }
783 
784  static _GLIBCXX_CONSTEXPR char8_t
785  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return char8_t(); }
786 
787  static _GLIBCXX_CONSTEXPR char8_t
788  denorm_min() _GLIBCXX_USE_NOEXCEPT { return char8_t(); }
789 
790  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
791  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
792  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = !is_signed;
793 
794  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
795  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
796  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
797  = round_toward_zero;
798  };
799 #endif
800 
801 #if __cplusplus >= 201103L
802  /// numeric_limits<char16_t> specialization.
803  template<>
804  struct numeric_limits<char16_t>
805  {
806  static constexpr bool is_specialized = true;
807 
808  static constexpr char16_t
809  min() noexcept { return __glibcxx_min (char16_t); }
810 
811  static constexpr char16_t
812  max() noexcept { return __glibcxx_max (char16_t); }
813 
814  static constexpr char16_t
815  lowest() noexcept { return min(); }
816 
817  static constexpr int digits = __glibcxx_digits (char16_t);
818  static constexpr int digits10 = __glibcxx_digits10 (char16_t);
819  static constexpr int max_digits10 = 0;
820  static constexpr bool is_signed = __glibcxx_signed (char16_t);
821  static constexpr bool is_integer = true;
822  static constexpr bool is_exact = true;
823  static constexpr int radix = 2;
824 
825  static constexpr char16_t
826  epsilon() noexcept { return 0; }
827 
828  static constexpr char16_t
829  round_error() noexcept { return 0; }
830 
831  static constexpr int min_exponent = 0;
832  static constexpr int min_exponent10 = 0;
833  static constexpr int max_exponent = 0;
834  static constexpr int max_exponent10 = 0;
835 
836  static constexpr bool has_infinity = false;
837  static constexpr bool has_quiet_NaN = false;
838  static constexpr bool has_signaling_NaN = false;
839  static constexpr float_denorm_style has_denorm = denorm_absent;
840  static constexpr bool has_denorm_loss = false;
841 
842  static constexpr char16_t
843  infinity() noexcept { return char16_t(); }
844 
845  static constexpr char16_t
846  quiet_NaN() noexcept { return char16_t(); }
847 
848  static constexpr char16_t
849  signaling_NaN() noexcept { return char16_t(); }
850 
851  static constexpr char16_t
852  denorm_min() noexcept { return char16_t(); }
853 
854  static constexpr bool is_iec559 = false;
855  static constexpr bool is_bounded = true;
856  static constexpr bool is_modulo = !is_signed;
857 
858  static constexpr bool traps = __glibcxx_integral_traps;
859  static constexpr bool tinyness_before = false;
860  static constexpr float_round_style round_style = round_toward_zero;
861  };
862 
863  /// numeric_limits<char32_t> specialization.
864  template<>
865  struct numeric_limits<char32_t>
866  {
867  static constexpr bool is_specialized = true;
868 
869  static constexpr char32_t
870  min() noexcept { return __glibcxx_min (char32_t); }
871 
872  static constexpr char32_t
873  max() noexcept { return __glibcxx_max (char32_t); }
874 
875  static constexpr char32_t
876  lowest() noexcept { return min(); }
877 
878  static constexpr int digits = __glibcxx_digits (char32_t);
879  static constexpr int digits10 = __glibcxx_digits10 (char32_t);
880  static constexpr int max_digits10 = 0;
881  static constexpr bool is_signed = __glibcxx_signed (char32_t);
882  static constexpr bool is_integer = true;
883  static constexpr bool is_exact = true;
884  static constexpr int radix = 2;
885 
886  static constexpr char32_t
887  epsilon() noexcept { return 0; }
888 
889  static constexpr char32_t
890  round_error() noexcept { return 0; }
891 
892  static constexpr int min_exponent = 0;
893  static constexpr int min_exponent10 = 0;
894  static constexpr int max_exponent = 0;
895  static constexpr int max_exponent10 = 0;
896 
897  static constexpr bool has_infinity = false;
898  static constexpr bool has_quiet_NaN = false;
899  static constexpr bool has_signaling_NaN = false;
900  static constexpr float_denorm_style has_denorm = denorm_absent;
901  static constexpr bool has_denorm_loss = false;
902 
903  static constexpr char32_t
904  infinity() noexcept { return char32_t(); }
905 
906  static constexpr char32_t
907  quiet_NaN() noexcept { return char32_t(); }
908 
909  static constexpr char32_t
910  signaling_NaN() noexcept { return char32_t(); }
911 
912  static constexpr char32_t
913  denorm_min() noexcept { return char32_t(); }
914 
915  static constexpr bool is_iec559 = false;
916  static constexpr bool is_bounded = true;
917  static constexpr bool is_modulo = !is_signed;
918 
919  static constexpr bool traps = __glibcxx_integral_traps;
920  static constexpr bool tinyness_before = false;
921  static constexpr float_round_style round_style = round_toward_zero;
922  };
923 #endif
924 
925  /// numeric_limits<short> specialization.
926  template<>
927  struct numeric_limits<short>
928  {
929  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
930 
931  static _GLIBCXX_CONSTEXPR short
932  min() _GLIBCXX_USE_NOEXCEPT { return -__SHRT_MAX__ - 1; }
933 
934  static _GLIBCXX_CONSTEXPR short
935  max() _GLIBCXX_USE_NOEXCEPT { return __SHRT_MAX__; }
936 
937 #if __cplusplus >= 201103L
938  static constexpr short
939  lowest() noexcept { return min(); }
940 #endif
941 
942  static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (short);
943  static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (short);
944 #if __cplusplus >= 201103L
945  static constexpr int max_digits10 = 0;
946 #endif
947  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
948  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
949  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
950  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
951 
952  static _GLIBCXX_CONSTEXPR short
953  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
954 
955  static _GLIBCXX_CONSTEXPR short
956  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
957 
958  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
959  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
960  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
961  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
962 
963  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
964  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
965  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
966  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
967  = denorm_absent;
968  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
969 
970  static _GLIBCXX_CONSTEXPR short
971  infinity() _GLIBCXX_USE_NOEXCEPT { return short(); }
972 
973  static _GLIBCXX_CONSTEXPR short
974  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return short(); }
975 
976  static _GLIBCXX_CONSTEXPR short
977  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return short(); }
978 
979  static _GLIBCXX_CONSTEXPR short
980  denorm_min() _GLIBCXX_USE_NOEXCEPT { return short(); }
981 
982  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
983  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
984  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
985 
986  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
987  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
988  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
989  = round_toward_zero;
990  };
991 
992  /// numeric_limits<unsigned short> specialization.
993  template<>
994  struct numeric_limits<unsigned short>
995  {
996  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
997 
998  static _GLIBCXX_CONSTEXPR unsigned short
999  min() _GLIBCXX_USE_NOEXCEPT { return 0; }
1000 
1001  static _GLIBCXX_CONSTEXPR unsigned short
1002  max() _GLIBCXX_USE_NOEXCEPT { return __SHRT_MAX__ * 2U + 1; }
1003 
1004 #if __cplusplus >= 201103L
1005  static constexpr unsigned short
1006  lowest() noexcept { return min(); }
1007 #endif
1008 
1009  static _GLIBCXX_USE_CONSTEXPR int digits
1010  = __glibcxx_digits (unsigned short);
1011  static _GLIBCXX_USE_CONSTEXPR int digits10
1012  = __glibcxx_digits10 (unsigned short);
1013 #if __cplusplus >= 201103L
1014  static constexpr int max_digits10 = 0;
1015 #endif
1016  static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
1017  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1018  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1019  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1020 
1021  static _GLIBCXX_CONSTEXPR unsigned short
1022  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1023 
1024  static _GLIBCXX_CONSTEXPR unsigned short
1025  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1026 
1027  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1028  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1029  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1030  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1031 
1032  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1033  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1034  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1035  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1036  = denorm_absent;
1037  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1038 
1039  static _GLIBCXX_CONSTEXPR unsigned short
1040  infinity() _GLIBCXX_USE_NOEXCEPT
1041  { return static_cast<unsigned short>(0); }
1042 
1043  static _GLIBCXX_CONSTEXPR unsigned short
1044  quiet_NaN() _GLIBCXX_USE_NOEXCEPT
1045  { return static_cast<unsigned short>(0); }
1046 
1047  static _GLIBCXX_CONSTEXPR unsigned short
1048  signaling_NaN() _GLIBCXX_USE_NOEXCEPT
1049  { return static_cast<unsigned short>(0); }
1050 
1051  static _GLIBCXX_CONSTEXPR unsigned short
1052  denorm_min() _GLIBCXX_USE_NOEXCEPT
1053  { return static_cast<unsigned short>(0); }
1054 
1055  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1056  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1057  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1058 
1059  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1060  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1061  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1062  = round_toward_zero;
1063  };
1064 
1065  /// numeric_limits<int> specialization.
1066  template<>
1067  struct numeric_limits<int>
1068  {
1069  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1070 
1071  static _GLIBCXX_CONSTEXPR int
1072  min() _GLIBCXX_USE_NOEXCEPT { return -__INT_MAX__ - 1; }
1073 
1074  static _GLIBCXX_CONSTEXPR int
1075  max() _GLIBCXX_USE_NOEXCEPT { return __INT_MAX__; }
1076 
1077 #if __cplusplus >= 201103L
1078  static constexpr int
1079  lowest() noexcept { return min(); }
1080 #endif
1081 
1082  static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (int);
1083  static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (int);
1084 #if __cplusplus >= 201103L
1085  static constexpr int max_digits10 = 0;
1086 #endif
1087  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1088  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1089  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1090  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1091 
1092  static _GLIBCXX_CONSTEXPR int
1093  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1094 
1095  static _GLIBCXX_CONSTEXPR int
1096  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1097 
1098  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1099  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1100  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1101  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1102 
1103  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1104  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1105  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1106  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1107  = denorm_absent;
1108  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1109 
1110  static _GLIBCXX_CONSTEXPR int
1111  infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
1112 
1113  static _GLIBCXX_CONSTEXPR int
1114  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
1115 
1116  static _GLIBCXX_CONSTEXPR int
1117  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
1118 
1119  static _GLIBCXX_CONSTEXPR int
1120  denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
1121 
1122  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1123  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1124  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1125 
1126  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1127  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1128  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1129  = round_toward_zero;
1130  };
1131 
1132  /// numeric_limits<unsigned int> specialization.
1133  template<>
1134  struct numeric_limits<unsigned int>
1135  {
1136  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1137 
1138  static _GLIBCXX_CONSTEXPR unsigned int
1139  min() _GLIBCXX_USE_NOEXCEPT { return 0; }
1140 
1141  static _GLIBCXX_CONSTEXPR unsigned int
1142  max() _GLIBCXX_USE_NOEXCEPT { return __INT_MAX__ * 2U + 1; }
1143 
1144 #if __cplusplus >= 201103L
1145  static constexpr unsigned int
1146  lowest() noexcept { return min(); }
1147 #endif
1148 
1149  static _GLIBCXX_USE_CONSTEXPR int digits
1150  = __glibcxx_digits (unsigned int);
1151  static _GLIBCXX_USE_CONSTEXPR int digits10
1152  = __glibcxx_digits10 (unsigned int);
1153 #if __cplusplus >= 201103L
1154  static constexpr int max_digits10 = 0;
1155 #endif
1156  static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
1157  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1158  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1159  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1160 
1161  static _GLIBCXX_CONSTEXPR unsigned int
1162  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1163 
1164  static _GLIBCXX_CONSTEXPR unsigned int
1165  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1166 
1167  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1168  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1169  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1170  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1171 
1172  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1173  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1174  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1175  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1176  = denorm_absent;
1177  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1178 
1179  static _GLIBCXX_CONSTEXPR unsigned int
1180  infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<unsigned int>(0); }
1181 
1182  static _GLIBCXX_CONSTEXPR unsigned int
1183  quiet_NaN() _GLIBCXX_USE_NOEXCEPT
1184  { return static_cast<unsigned int>(0); }
1185 
1186  static _GLIBCXX_CONSTEXPR unsigned int
1187  signaling_NaN() _GLIBCXX_USE_NOEXCEPT
1188  { return static_cast<unsigned int>(0); }
1189 
1190  static _GLIBCXX_CONSTEXPR unsigned int
1191  denorm_min() _GLIBCXX_USE_NOEXCEPT
1192  { return static_cast<unsigned int>(0); }
1193 
1194  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1195  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1196  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1197 
1198  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1199  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1200  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1201  = round_toward_zero;
1202  };
1203 
1204  /// numeric_limits<long> specialization.
1205  template<>
1206  struct numeric_limits<long>
1207  {
1208  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1209 
1210  static _GLIBCXX_CONSTEXPR long
1211  min() _GLIBCXX_USE_NOEXCEPT { return -__LONG_MAX__ - 1; }
1212 
1213  static _GLIBCXX_CONSTEXPR long
1214  max() _GLIBCXX_USE_NOEXCEPT { return __LONG_MAX__; }
1215 
1216 #if __cplusplus >= 201103L
1217  static constexpr long
1218  lowest() noexcept { return min(); }
1219 #endif
1220 
1221  static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (long);
1222  static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (long);
1223 #if __cplusplus >= 201103L
1224  static constexpr int max_digits10 = 0;
1225 #endif
1226  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1227  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1228  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1229  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1230 
1231  static _GLIBCXX_CONSTEXPR long
1232  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1233 
1234  static _GLIBCXX_CONSTEXPR long
1235  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1236 
1237  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1238  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1239  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1240  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1241 
1242  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1243  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1244  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1245  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1246  = denorm_absent;
1247  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1248 
1249  static _GLIBCXX_CONSTEXPR long
1250  infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
1251 
1252  static _GLIBCXX_CONSTEXPR long
1253  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
1254 
1255  static _GLIBCXX_CONSTEXPR long
1256  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
1257 
1258  static _GLIBCXX_CONSTEXPR long
1259  denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
1260 
1261  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1262  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1263  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1264 
1265  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1266  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1267  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1268  = round_toward_zero;
1269  };
1270 
1271  /// numeric_limits<unsigned long> specialization.
1272  template<>
1273  struct numeric_limits<unsigned long>
1274  {
1275  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1276 
1277  static _GLIBCXX_CONSTEXPR unsigned long
1278  min() _GLIBCXX_USE_NOEXCEPT { return 0; }
1279 
1280  static _GLIBCXX_CONSTEXPR unsigned long
1281  max() _GLIBCXX_USE_NOEXCEPT { return __LONG_MAX__ * 2UL + 1; }
1282 
1283 #if __cplusplus >= 201103L
1284  static constexpr unsigned long
1285  lowest() noexcept { return min(); }
1286 #endif
1287 
1288  static _GLIBCXX_USE_CONSTEXPR int digits
1289  = __glibcxx_digits (unsigned long);
1290  static _GLIBCXX_USE_CONSTEXPR int digits10
1291  = __glibcxx_digits10 (unsigned long);
1292 #if __cplusplus >= 201103L
1293  static constexpr int max_digits10 = 0;
1294 #endif
1295  static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
1296  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1297  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1298  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1299 
1300  static _GLIBCXX_CONSTEXPR unsigned long
1301  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1302 
1303  static _GLIBCXX_CONSTEXPR unsigned long
1304  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1305 
1306  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1307  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1308  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1309  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1310 
1311  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1312  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1313  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1314  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1315  = denorm_absent;
1316  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1317 
1318  static _GLIBCXX_CONSTEXPR unsigned long
1319  infinity() _GLIBCXX_USE_NOEXCEPT
1320  { return static_cast<unsigned long>(0); }
1321 
1322  static _GLIBCXX_CONSTEXPR unsigned long
1323  quiet_NaN() _GLIBCXX_USE_NOEXCEPT
1324  { return static_cast<unsigned long>(0); }
1325 
1326  static _GLIBCXX_CONSTEXPR unsigned long
1327  signaling_NaN() _GLIBCXX_USE_NOEXCEPT
1328  { return static_cast<unsigned long>(0); }
1329 
1330  static _GLIBCXX_CONSTEXPR unsigned long
1331  denorm_min() _GLIBCXX_USE_NOEXCEPT
1332  { return static_cast<unsigned long>(0); }
1333 
1334  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1335  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1336  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1337 
1338  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1339  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1340  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1341  = round_toward_zero;
1342  };
1343 
1344  /// numeric_limits<long long> specialization.
1345  template<>
1346  struct numeric_limits<long long>
1347  {
1348  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1349 
1350  static _GLIBCXX_CONSTEXPR long long
1351  min() _GLIBCXX_USE_NOEXCEPT { return -__LONG_LONG_MAX__ - 1; }
1352 
1353  static _GLIBCXX_CONSTEXPR long long
1354  max() _GLIBCXX_USE_NOEXCEPT { return __LONG_LONG_MAX__; }
1355 
1356 #if __cplusplus >= 201103L
1357  static constexpr long long
1358  lowest() noexcept { return min(); }
1359 #endif
1360 
1361  static _GLIBCXX_USE_CONSTEXPR int digits
1362  = __glibcxx_digits (long long);
1363  static _GLIBCXX_USE_CONSTEXPR int digits10
1364  = __glibcxx_digits10 (long long);
1365 #if __cplusplus >= 201103L
1366  static constexpr int max_digits10 = 0;
1367 #endif
1368  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1369  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1370  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1371  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1372 
1373  static _GLIBCXX_CONSTEXPR long long
1374  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1375 
1376  static _GLIBCXX_CONSTEXPR long long
1377  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1378 
1379  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1380  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1381  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1382  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1383 
1384  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1385  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1386  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1387  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1388  = denorm_absent;
1389  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1390 
1391  static _GLIBCXX_CONSTEXPR long long
1392  infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); }
1393 
1394  static _GLIBCXX_CONSTEXPR long long
1395  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); }
1396 
1397  static _GLIBCXX_CONSTEXPR long long
1398  signaling_NaN() _GLIBCXX_USE_NOEXCEPT
1399  { return static_cast<long long>(0); }
1400 
1401  static _GLIBCXX_CONSTEXPR long long
1402  denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); }
1403 
1404  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1405  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1406  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1407 
1408  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1409  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1410  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1411  = round_toward_zero;
1412  };
1413 
1414  /// numeric_limits<unsigned long long> specialization.
1415  template<>
1416  struct numeric_limits<unsigned long long>
1417  {
1418  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1419 
1420  static _GLIBCXX_CONSTEXPR unsigned long long
1421  min() _GLIBCXX_USE_NOEXCEPT { return 0; }
1422 
1423  static _GLIBCXX_CONSTEXPR unsigned long long
1424  max() _GLIBCXX_USE_NOEXCEPT { return __LONG_LONG_MAX__ * 2ULL + 1; }
1425 
1426 #if __cplusplus >= 201103L
1427  static constexpr unsigned long long
1428  lowest() noexcept { return min(); }
1429 #endif
1430 
1431  static _GLIBCXX_USE_CONSTEXPR int digits
1432  = __glibcxx_digits (unsigned long long);
1433  static _GLIBCXX_USE_CONSTEXPR int digits10
1434  = __glibcxx_digits10 (unsigned long long);
1435 #if __cplusplus >= 201103L
1436  static constexpr int max_digits10 = 0;
1437 #endif
1438  static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
1439  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1440  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1441  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1442 
1443  static _GLIBCXX_CONSTEXPR unsigned long long
1444  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1445 
1446  static _GLIBCXX_CONSTEXPR unsigned long long
1447  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1448 
1449  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1450  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1451  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1452  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1453 
1454  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1455  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1456  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1457  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1458  = denorm_absent;
1459  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1460 
1461  static _GLIBCXX_CONSTEXPR unsigned long long
1462  infinity() _GLIBCXX_USE_NOEXCEPT
1463  { return static_cast<unsigned long long>(0); }
1464 
1465  static _GLIBCXX_CONSTEXPR unsigned long long
1466  quiet_NaN() _GLIBCXX_USE_NOEXCEPT
1467  { return static_cast<unsigned long long>(0); }
1468 
1469  static _GLIBCXX_CONSTEXPR unsigned long long
1470  signaling_NaN() _GLIBCXX_USE_NOEXCEPT
1471  { return static_cast<unsigned long long>(0); }
1472 
1473  static _GLIBCXX_CONSTEXPR unsigned long long
1474  denorm_min() _GLIBCXX_USE_NOEXCEPT
1475  { return static_cast<unsigned long long>(0); }
1476 
1477  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1478  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1479  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1480 
1481  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1482  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1483  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1484  = round_toward_zero;
1485  };
1486 
1487 #define __INT_N(TYPE, BITSIZE, EXT, UEXT) \
1488  __extension__ \
1489  template<> \
1490  struct numeric_limits<TYPE> \
1491  { \
1492  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; \
1493  \
1494  static _GLIBCXX_CONSTEXPR TYPE \
1495  min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min_b (TYPE, BITSIZE); } \
1496  \
1497  static _GLIBCXX_CONSTEXPR TYPE \
1498  max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max_b (TYPE, BITSIZE); } \
1499  \
1500  static _GLIBCXX_USE_CONSTEXPR int digits \
1501  = BITSIZE - 1; \
1502  static _GLIBCXX_USE_CONSTEXPR int digits10 \
1503  = (BITSIZE - 1) * 643L / 2136; \
1504  \
1505  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; \
1506  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; \
1507  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; \
1508  static _GLIBCXX_USE_CONSTEXPR int radix = 2; \
1509  \
1510  static _GLIBCXX_CONSTEXPR TYPE \
1511  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } \
1512  \
1513  static _GLIBCXX_CONSTEXPR TYPE \
1514  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } \
1515  \
1516  EXT \
1517  \
1518  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; \
1519  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; \
1520  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; \
1521  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; \
1522  \
1523  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; \
1524  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; \
1525  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; \
1526  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm \
1527  = denorm_absent; \
1528  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; \
1529  \
1530  static _GLIBCXX_CONSTEXPR TYPE \
1531  infinity() _GLIBCXX_USE_NOEXCEPT \
1532  { return static_cast<TYPE>(0); } \
1533  \
1534  static _GLIBCXX_CONSTEXPR TYPE \
1535  quiet_NaN() _GLIBCXX_USE_NOEXCEPT \
1536  { return static_cast<TYPE>(0); } \
1537  \
1538  static _GLIBCXX_CONSTEXPR TYPE \
1539  signaling_NaN() _GLIBCXX_USE_NOEXCEPT \
1540  { return static_cast<TYPE>(0); } \
1541  \
1542  static _GLIBCXX_CONSTEXPR TYPE \
1543  denorm_min() _GLIBCXX_USE_NOEXCEPT \
1544  { return static_cast<TYPE>(0); } \
1545  \
1546  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; \
1547  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; \
1548  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; \
1549  \
1550  static _GLIBCXX_USE_CONSTEXPR bool traps \
1551  = __glibcxx_integral_traps; \
1552  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; \
1553  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style \
1554  = round_toward_zero; \
1555  }; \
1556  \
1557  __extension__ \
1558  template<> \
1559  struct numeric_limits<unsigned TYPE> \
1560  { \
1561  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; \
1562  \
1563  static _GLIBCXX_CONSTEXPR unsigned TYPE \
1564  min() _GLIBCXX_USE_NOEXCEPT { return 0; } \
1565  \
1566  static _GLIBCXX_CONSTEXPR unsigned TYPE \
1567  max() _GLIBCXX_USE_NOEXCEPT \
1568  { return __glibcxx_max_b (unsigned TYPE, BITSIZE); } \
1569  \
1570  UEXT \
1571  \
1572  static _GLIBCXX_USE_CONSTEXPR int digits \
1573  = BITSIZE; \
1574  static _GLIBCXX_USE_CONSTEXPR int digits10 \
1575  = BITSIZE * 643L / 2136; \
1576  static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; \
1577  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; \
1578  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; \
1579  static _GLIBCXX_USE_CONSTEXPR int radix = 2; \
1580  \
1581  static _GLIBCXX_CONSTEXPR unsigned TYPE \
1582  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } \
1583  \
1584  static _GLIBCXX_CONSTEXPR unsigned TYPE \
1585  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } \
1586  \
1587  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; \
1588  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; \
1589  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; \
1590  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; \
1591  \
1592  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; \
1593  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; \
1594  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; \
1595  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm \
1596  = denorm_absent; \
1597  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; \
1598  \
1599  static _GLIBCXX_CONSTEXPR unsigned TYPE \
1600  infinity() _GLIBCXX_USE_NOEXCEPT \
1601  { return static_cast<unsigned TYPE>(0); } \
1602  \
1603  static _GLIBCXX_CONSTEXPR unsigned TYPE \
1604  quiet_NaN() _GLIBCXX_USE_NOEXCEPT \
1605  { return static_cast<unsigned TYPE>(0); } \
1606  \
1607  static _GLIBCXX_CONSTEXPR unsigned TYPE \
1608  signaling_NaN() _GLIBCXX_USE_NOEXCEPT \
1609  { return static_cast<unsigned TYPE>(0); } \
1610  \
1611  static _GLIBCXX_CONSTEXPR unsigned TYPE \
1612  denorm_min() _GLIBCXX_USE_NOEXCEPT \
1613  { return static_cast<unsigned TYPE>(0); } \
1614  \
1615  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; \
1616  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; \
1617  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; \
1618  \
1619  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; \
1620  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; \
1621  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style \
1622  = round_toward_zero; \
1623  };
1624 
1625 #if __cplusplus >= 201103L
1626 
1627 #define __INT_N_201103(TYPE) \
1628  static constexpr TYPE \
1629  lowest() noexcept { return min(); } \
1630  static constexpr int max_digits10 = 0;
1631 
1632 #define __INT_N_U201103(TYPE) \
1633  static constexpr unsigned TYPE \
1634  lowest() noexcept { return min(); } \
1635  static constexpr int max_digits10 = 0;
1636 
1637 #else
1638 #define __INT_N_201103(TYPE)
1639 #define __INT_N_U201103(TYPE)
1640 #endif
1641 
1642 #if !defined(__STRICT_ANSI__)
1643 #ifdef __GLIBCXX_TYPE_INT_N_0
1644  __INT_N(__GLIBCXX_TYPE_INT_N_0, __GLIBCXX_BITSIZE_INT_N_0,
1645  __INT_N_201103 (__GLIBCXX_TYPE_INT_N_0),
1646  __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_0))
1647 #endif
1648 #ifdef __GLIBCXX_TYPE_INT_N_1
1649  __INT_N (__GLIBCXX_TYPE_INT_N_1, __GLIBCXX_BITSIZE_INT_N_1,
1650  __INT_N_201103 (__GLIBCXX_TYPE_INT_N_1),
1651  __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_1))
1652 #endif
1653 #ifdef __GLIBCXX_TYPE_INT_N_2
1654  __INT_N (__GLIBCXX_TYPE_INT_N_2, __GLIBCXX_BITSIZE_INT_N_2,
1655  __INT_N_201103 (__GLIBCXX_TYPE_INT_N_2),
1656  __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_2))
1657 #endif
1658 #ifdef __GLIBCXX_TYPE_INT_N_3
1659  __INT_N (__GLIBCXX_TYPE_INT_N_3, __GLIBCXX_BITSIZE_INT_N_3,
1660  __INT_N_201103 (__GLIBCXX_TYPE_INT_N_3),
1661  __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_3))
1662 #endif
1663 
1664 #elif defined __STRICT_ANSI__ && defined __SIZEOF_INT128__
1665  __INT_N(__int128, 128,
1666  __INT_N_201103 (__int128),
1667  __INT_N_U201103 (__int128))
1668 #endif
1669 
1670 #undef __INT_N
1671 #undef __INT_N_201103
1672 #undef __INT_N_U201103
1673 
1674 
1675  /// numeric_limits<float> specialization.
1676  template<>
1677  struct numeric_limits<float>
1678  {
1679  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1680 
1681  static _GLIBCXX_CONSTEXPR float
1682  min() _GLIBCXX_USE_NOEXCEPT { return __FLT_MIN__; }
1683 
1684  static _GLIBCXX_CONSTEXPR float
1685  max() _GLIBCXX_USE_NOEXCEPT { return __FLT_MAX__; }
1686 
1687 #if __cplusplus >= 201103L
1688  static constexpr float
1689  lowest() noexcept { return -__FLT_MAX__; }
1690 #endif
1691 
1692  static _GLIBCXX_USE_CONSTEXPR int digits = __FLT_MANT_DIG__;
1693  static _GLIBCXX_USE_CONSTEXPR int digits10 = __FLT_DIG__;
1694 #if __cplusplus >= 201103L
1695  static constexpr int max_digits10
1696  = __glibcxx_max_digits10 (__FLT_MANT_DIG__);
1697 #endif
1698  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1699  static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
1700  static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
1701  static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
1702 
1703  static _GLIBCXX_CONSTEXPR float
1704  epsilon() _GLIBCXX_USE_NOEXCEPT { return __FLT_EPSILON__; }
1705 
1706  static _GLIBCXX_CONSTEXPR float
1707  round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5F; }
1708 
1709  static _GLIBCXX_USE_CONSTEXPR int min_exponent = __FLT_MIN_EXP__;
1710  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __FLT_MIN_10_EXP__;
1711  static _GLIBCXX_USE_CONSTEXPR int max_exponent = __FLT_MAX_EXP__;
1712  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __FLT_MAX_10_EXP__;
1713 
1714  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __FLT_HAS_INFINITY__;
1715  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __FLT_HAS_QUIET_NAN__;
1716  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN;
1717  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1718  = bool(__FLT_HAS_DENORM__) ? denorm_present : denorm_absent;
1719  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
1720  = __glibcxx_float_has_denorm_loss;
1721 
1722  static _GLIBCXX_CONSTEXPR float
1723  infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_valf(); }
1724 
1725  static _GLIBCXX_CONSTEXPR float
1726  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nanf(""); }
1727 
1728  static _GLIBCXX_CONSTEXPR float
1729  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nansf(""); }
1730 
1731  static _GLIBCXX_CONSTEXPR float
1732  denorm_min() _GLIBCXX_USE_NOEXCEPT { return __FLT_DENORM_MIN__; }
1733 
1734  static _GLIBCXX_USE_CONSTEXPR bool is_iec559
1735  = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
1736  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1737  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1738 
1739  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_float_traps;
1740  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before
1741  = __glibcxx_float_tinyness_before;
1742  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1743  = round_to_nearest;
1744  };
1745 
1746 #undef __glibcxx_float_has_denorm_loss
1747 #undef __glibcxx_float_traps
1748 #undef __glibcxx_float_tinyness_before
1749 
1750  /// numeric_limits<double> specialization.
1751  template<>
1752  struct numeric_limits<double>
1753  {
1754  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1755 
1756  static _GLIBCXX_CONSTEXPR double
1757  min() _GLIBCXX_USE_NOEXCEPT { return __DBL_MIN__; }
1758 
1759  static _GLIBCXX_CONSTEXPR double
1760  max() _GLIBCXX_USE_NOEXCEPT { return __DBL_MAX__; }
1761 
1762 #if __cplusplus >= 201103L
1763  static constexpr double
1764  lowest() noexcept { return -__DBL_MAX__; }
1765 #endif
1766 
1767  static _GLIBCXX_USE_CONSTEXPR int digits = __DBL_MANT_DIG__;
1768  static _GLIBCXX_USE_CONSTEXPR int digits10 = __DBL_DIG__;
1769 #if __cplusplus >= 201103L
1770  static constexpr int max_digits10
1771  = __glibcxx_max_digits10 (__DBL_MANT_DIG__);
1772 #endif
1773  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1774  static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
1775  static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
1776  static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
1777 
1778  static _GLIBCXX_CONSTEXPR double
1779  epsilon() _GLIBCXX_USE_NOEXCEPT { return __DBL_EPSILON__; }
1780 
1781  static _GLIBCXX_CONSTEXPR double
1782  round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5; }
1783 
1784  static _GLIBCXX_USE_CONSTEXPR int min_exponent = __DBL_MIN_EXP__;
1785  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __DBL_MIN_10_EXP__;
1786  static _GLIBCXX_USE_CONSTEXPR int max_exponent = __DBL_MAX_EXP__;
1787  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __DBL_MAX_10_EXP__;
1788 
1789  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __DBL_HAS_INFINITY__;
1790  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __DBL_HAS_QUIET_NAN__;
1791  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN;
1792  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1793  = bool(__DBL_HAS_DENORM__) ? denorm_present : denorm_absent;
1794  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
1795  = __glibcxx_double_has_denorm_loss;
1796 
1797  static _GLIBCXX_CONSTEXPR double
1798  infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_val(); }
1799 
1800  static _GLIBCXX_CONSTEXPR double
1801  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nan(""); }
1802 
1803  static _GLIBCXX_CONSTEXPR double
1804  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nans(""); }
1805 
1806  static _GLIBCXX_CONSTEXPR double
1807  denorm_min() _GLIBCXX_USE_NOEXCEPT { return __DBL_DENORM_MIN__; }
1808 
1809  static _GLIBCXX_USE_CONSTEXPR bool is_iec559
1810  = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
1811  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1812  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1813 
1814  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_double_traps;
1815  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before
1816  = __glibcxx_double_tinyness_before;
1817  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1818  = round_to_nearest;
1819  };
1820 
1821 #undef __glibcxx_double_has_denorm_loss
1822 #undef __glibcxx_double_traps
1823 #undef __glibcxx_double_tinyness_before
1824 
1825  /// numeric_limits<long double> specialization.
1826  template<>
1827  struct numeric_limits<long double>
1828  {
1829  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1830 
1831  static _GLIBCXX_CONSTEXPR long double
1832  min() _GLIBCXX_USE_NOEXCEPT { return __LDBL_MIN__; }
1833 
1834  static _GLIBCXX_CONSTEXPR long double
1835  max() _GLIBCXX_USE_NOEXCEPT { return __LDBL_MAX__; }
1836 
1837 #if __cplusplus >= 201103L
1838  static constexpr long double
1839  lowest() noexcept { return -__LDBL_MAX__; }
1840 #endif
1841 
1842  static _GLIBCXX_USE_CONSTEXPR int digits = __LDBL_MANT_DIG__;
1843  static _GLIBCXX_USE_CONSTEXPR int digits10 = __LDBL_DIG__;
1844 #if __cplusplus >= 201103L
1845  static _GLIBCXX_USE_CONSTEXPR int max_digits10
1846  = __glibcxx_max_digits10 (__LDBL_MANT_DIG__);
1847 #endif
1848  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1849  static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
1850  static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
1851  static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
1852 
1853  static _GLIBCXX_CONSTEXPR long double
1854  epsilon() _GLIBCXX_USE_NOEXCEPT { return __LDBL_EPSILON__; }
1855 
1856  static _GLIBCXX_CONSTEXPR long double
1857  round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5L; }
1858 
1859  static _GLIBCXX_USE_CONSTEXPR int min_exponent = __LDBL_MIN_EXP__;
1860  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __LDBL_MIN_10_EXP__;
1861  static _GLIBCXX_USE_CONSTEXPR int max_exponent = __LDBL_MAX_EXP__;
1862  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __LDBL_MAX_10_EXP__;
1863 
1864  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __LDBL_HAS_INFINITY__;
1865  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __LDBL_HAS_QUIET_NAN__;
1866  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN;
1867  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1868  = bool(__LDBL_HAS_DENORM__) ? denorm_present : denorm_absent;
1869  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
1870  = __glibcxx_long_double_has_denorm_loss;
1871 
1872  static _GLIBCXX_CONSTEXPR long double
1873  infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_vall(); }
1874 
1875  static _GLIBCXX_CONSTEXPR long double
1876  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nanl(""); }
1877 
1878  static _GLIBCXX_CONSTEXPR long double
1879  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nansl(""); }
1880 
1881  static _GLIBCXX_CONSTEXPR long double
1882  denorm_min() _GLIBCXX_USE_NOEXCEPT { return __LDBL_DENORM_MIN__; }
1883 
1884  static _GLIBCXX_USE_CONSTEXPR bool is_iec559
1885  = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
1886  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1887  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1888 
1889  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_long_double_traps;
1890  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before =
1891  __glibcxx_long_double_tinyness_before;
1892  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style =
1893  round_to_nearest;
1894  };
1895 
1896 #undef __glibcxx_long_double_has_denorm_loss
1897 #undef __glibcxx_long_double_traps
1898 #undef __glibcxx_long_double_tinyness_before
1899 
1900 #define __glibcxx_concat3_(P,M,S) P ## M ## S
1901 #define __glibcxx_concat3(P,M,S) __glibcxx_concat3_ (P,M,S)
1902 
1903 #if __cplusplus >= 201103L
1904 # define __max_digits10 max_digits10
1905 #endif
1906 
1907 #define __glibcxx_float_n(BITSIZE) \
1908  __extension__ \
1909  template<> \
1910  struct numeric_limits<_Float##BITSIZE> \
1911  { \
1912  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; \
1913  \
1914  static _GLIBCXX_CONSTEXPR _Float##BITSIZE \
1915  min() _GLIBCXX_USE_NOEXCEPT \
1916  { return __glibcxx_concat3 (__FLT, BITSIZE, _MIN__); } \
1917  \
1918  static _GLIBCXX_CONSTEXPR _Float##BITSIZE \
1919  max() _GLIBCXX_USE_NOEXCEPT \
1920  { return __glibcxx_concat3 (__FLT, BITSIZE, _MAX__); } \
1921  \
1922  static _GLIBCXX_CONSTEXPR _Float##BITSIZE \
1923  lowest() _GLIBCXX_USE_NOEXCEPT \
1924  { return -__glibcxx_concat3 (__FLT, BITSIZE, _MAX__); } \
1925  \
1926  static _GLIBCXX_USE_CONSTEXPR int digits \
1927  = __glibcxx_concat3 (__FLT, BITSIZE, _MANT_DIG__); \
1928  static _GLIBCXX_USE_CONSTEXPR int digits10 \
1929  = __glibcxx_concat3 (__FLT, BITSIZE, _DIG__); \
1930  static _GLIBCXX_USE_CONSTEXPR int __max_digits10 \
1931  = __glibcxx_max_digits10 (__glibcxx_concat3 (__FLT, BITSIZE, \
1932  _MANT_DIG__)); \
1933  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; \
1934  static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; \
1935  static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; \
1936  static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; \
1937  \
1938  static _GLIBCXX_CONSTEXPR _Float##BITSIZE \
1939  epsilon() _GLIBCXX_USE_NOEXCEPT \
1940  { return __glibcxx_concat3 (__FLT, BITSIZE, _EPSILON__); } \
1941  \
1942  static _GLIBCXX_CONSTEXPR _Float##BITSIZE \
1943  round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5F##BITSIZE; } \
1944  \
1945  static _GLIBCXX_USE_CONSTEXPR int min_exponent \
1946  = __glibcxx_concat3 (__FLT, BITSIZE, _MIN_EXP__); \
1947  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 \
1948  = __glibcxx_concat3 (__FLT, BITSIZE, _MIN_10_EXP__); \
1949  static _GLIBCXX_USE_CONSTEXPR int max_exponent \
1950  = __glibcxx_concat3 (__FLT, BITSIZE, _MAX_EXP__); \
1951  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 \
1952  = __glibcxx_concat3 (__FLT, BITSIZE, _MAX_10_EXP__); \
1953  \
1954  static _GLIBCXX_USE_CONSTEXPR bool has_infinity \
1955  = __glibcxx_concat3 (__FLT, BITSIZE, _HAS_INFINITY__); \
1956  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN \
1957  = __glibcxx_concat3 (__FLT, BITSIZE, _HAS_QUIET_NAN__); \
1958  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN \
1959  = has_quiet_NaN; \
1960  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm \
1961  = bool(__glibcxx_concat3 (__FLT, BITSIZE, _HAS_DENORM__)) \
1962  ? denorm_present : denorm_absent; \
1963  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; \
1964  \
1965  static _GLIBCXX_CONSTEXPR _Float##BITSIZE \
1966  infinity() _GLIBCXX_USE_NOEXCEPT \
1967  { return __builtin_huge_valf##BITSIZE(); } \
1968  \
1969  static _GLIBCXX_CONSTEXPR _Float##BITSIZE \
1970  quiet_NaN() _GLIBCXX_USE_NOEXCEPT \
1971  { return __builtin_nanf##BITSIZE(""); } \
1972  \
1973  static _GLIBCXX_CONSTEXPR _Float##BITSIZE \
1974  signaling_NaN() _GLIBCXX_USE_NOEXCEPT \
1975  { return __builtin_nansf##BITSIZE(""); } \
1976  \
1977  static _GLIBCXX_CONSTEXPR _Float##BITSIZE \
1978  denorm_min() _GLIBCXX_USE_NOEXCEPT \
1979  { return __glibcxx_concat3 (__FLT, BITSIZE, _DENORM_MIN__); } \
1980  \
1981  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 \
1982  = has_infinity && has_quiet_NaN && has_denorm == denorm_present;\
1983  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; \
1984  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; \
1985  \
1986  static _GLIBCXX_USE_CONSTEXPR bool traps = false; \
1987  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; \
1988  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style \
1989  = round_to_nearest; \
1990  }; \
1991 
1992 #ifdef __STDCPP_FLOAT16_T__
1993 __glibcxx_float_n(16)
1994 #endif
1995 #ifdef __FLT32_DIG__
1996 __glibcxx_float_n(32)
1997 #endif
1998 #ifdef __FLT64_DIG__
1999 __glibcxx_float_n(64)
2000 #endif
2001 #ifdef __FLT128_DIG__
2002 __glibcxx_float_n(128)
2003 #endif
2004 #undef __glibcxx_float_n
2005 #undef __glibcxx_concat3
2006 #undef __glibcxx_concat3_
2007 
2008 #if __cplusplus >= 201103L
2009 # undef __max_digits10
2010 #endif
2011 
2012 #ifdef __STDCPP_BFLOAT16_T__
2013  __extension__
2014  template<>
2015  struct numeric_limits<__gnu_cxx::__bfloat16_t>
2016  {
2017  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
2018 
2019  static _GLIBCXX_CONSTEXPR __gnu_cxx::__bfloat16_t
2020  min() _GLIBCXX_USE_NOEXCEPT
2021  { return __BFLT16_MIN__; }
2022 
2023  static _GLIBCXX_CONSTEXPR __gnu_cxx::__bfloat16_t
2024  max() _GLIBCXX_USE_NOEXCEPT
2025  { return __BFLT16_MAX__; }
2026 
2027  static _GLIBCXX_CONSTEXPR __gnu_cxx::__bfloat16_t
2028  lowest() _GLIBCXX_USE_NOEXCEPT
2029  { return -__BFLT16_MAX__; }
2030 
2031  static _GLIBCXX_USE_CONSTEXPR int digits = __BFLT16_MANT_DIG__;
2032  static _GLIBCXX_USE_CONSTEXPR int digits10 = __BFLT16_DIG__;
2033 #if __cplusplus >= 201103L
2034  static _GLIBCXX_USE_CONSTEXPR int max_digits10
2035  = __glibcxx_max_digits10 (__BFLT16_MANT_DIG__);
2036 #endif
2037  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
2038  static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
2039  static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
2040  static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
2041 
2042  static _GLIBCXX_CONSTEXPR __gnu_cxx::__bfloat16_t
2043  epsilon() _GLIBCXX_USE_NOEXCEPT
2044  { return __BFLT16_EPSILON__; }
2045 
2046  static _GLIBCXX_CONSTEXPR __gnu_cxx::__bfloat16_t
2047  round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5BF16; }
2048 
2049  static _GLIBCXX_USE_CONSTEXPR int min_exponent = __BFLT16_MIN_EXP__;
2050  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __BFLT16_MIN_10_EXP__;
2051  static _GLIBCXX_USE_CONSTEXPR int max_exponent = __BFLT16_MAX_EXP__;
2052  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __BFLT16_MAX_10_EXP__;
2053 
2054  static _GLIBCXX_USE_CONSTEXPR bool has_infinity
2055  = __BFLT16_HAS_INFINITY__;
2056  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN
2057  = __BFLT16_HAS_QUIET_NAN__;
2058  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN;
2059  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
2060  = bool(__BFLT16_HAS_DENORM__) ? denorm_present : denorm_absent;
2061  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
2062 
2063  static _GLIBCXX_CONSTEXPR __gnu_cxx::__bfloat16_t
2064  infinity() _GLIBCXX_USE_NOEXCEPT
2065  { return __gnu_cxx::__bfloat16_t(__builtin_huge_valf()); }
2066 
2067  static _GLIBCXX_CONSTEXPR __gnu_cxx::__bfloat16_t
2068  quiet_NaN() _GLIBCXX_USE_NOEXCEPT
2069  { return __gnu_cxx::__bfloat16_t(__builtin_nanf("")); }
2070 
2071  static _GLIBCXX_CONSTEXPR __gnu_cxx::__bfloat16_t
2072  signaling_NaN() _GLIBCXX_USE_NOEXCEPT
2073  { return __builtin_nansf16b(""); }
2074 
2075  static _GLIBCXX_CONSTEXPR __gnu_cxx::__bfloat16_t
2076  denorm_min() _GLIBCXX_USE_NOEXCEPT
2077  { return __BFLT16_DENORM_MIN__; }
2078 
2079  static _GLIBCXX_USE_CONSTEXPR bool is_iec559
2080  = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
2081  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
2082  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
2083 
2084  static _GLIBCXX_USE_CONSTEXPR bool traps = false;
2085  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
2086  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
2087  = round_to_nearest;
2088  };
2089 #endif // __STDCPP_BFLOAT16_T__
2090 
2091 #if defined(_GLIBCXX_USE_FLOAT128)
2092 // We either need Q literal suffixes, or IEEE double.
2093 #if ! defined(__STRICT_ANSI__) || defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
2094  __extension__
2095  template<>
2096  struct numeric_limits<__float128>
2097  {
2098  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
2099 
2100  static _GLIBCXX_CONSTEXPR __float128
2101  min() _GLIBCXX_USE_NOEXCEPT
2102  {
2103 #ifdef __STRICT_ANSI__
2104  // 0x1.0p-30 * 0x1.0p-16352
2105  return double(9.3132257461547852e-10) * _S_1pm16352();
2106 #else
2107  return __extension__ 0x1.0p-16382Q;
2108 #endif
2109  }
2110 
2111  static _GLIBCXX_CONSTEXPR __float128
2112  max() _GLIBCXX_USE_NOEXCEPT
2113  {
2114 #ifdef __STRICT_ANSI__
2115  // (0x1.fffffffffffffp+127 + 0x0.fffffffffffffp+75 + 0x0.ffp+23)
2116  // * 0x1.0p16256
2117  return (__float128(double(3.4028236692093843e+38))
2118  + double(3.7778931862957153e+22) + double(8.35584e+6))
2119  * _S_1p16256();
2120 #else
2121  return __extension__ 0x1.ffffffffffffffffffffffffffffp+16383Q;
2122 #endif
2123  }
2124 
2125  static _GLIBCXX_CONSTEXPR __float128
2126  lowest() _GLIBCXX_USE_NOEXCEPT
2127  { return -max(); }
2128 
2129  static _GLIBCXX_USE_CONSTEXPR int digits = 113;
2130  static _GLIBCXX_USE_CONSTEXPR int digits10 = 33;
2131 #if __cplusplus >= 201103L
2132  static constexpr int max_digits10 = 35;
2133 #endif
2134  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
2135  static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
2136  static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
2137  static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
2138 
2139  static _GLIBCXX_CONSTEXPR __float128
2140  epsilon() _GLIBCXX_USE_NOEXCEPT
2141  { return double(1.9259299443872359e-34); }
2142 
2143  static _GLIBCXX_CONSTEXPR __float128
2144  round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5; }
2145 
2146  static _GLIBCXX_USE_CONSTEXPR int min_exponent = -16381;
2147  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = -4931;
2148  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 16384;
2149  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 4932;
2150 
2151  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = 1;
2152  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = 1;
2153 #if __has_builtin(__builtin_nansq) \
2154  || (__has_builtin(__builtin_bit_cast) && __has_builtin(__builtin_nansf128))
2155  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = true;
2156 #else
2157  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
2158 #endif
2159  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
2160  = denorm_present;
2161  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
2162 
2163  static _GLIBCXX_CONSTEXPR __float128
2164  infinity() _GLIBCXX_USE_NOEXCEPT
2165  { return __builtin_huge_val(); }
2166 
2167  static _GLIBCXX_CONSTEXPR __float128
2168  quiet_NaN() _GLIBCXX_USE_NOEXCEPT
2169  { return __builtin_nan(""); }
2170 
2171  static _GLIBCXX_CONSTEXPR __float128
2172  signaling_NaN() _GLIBCXX_USE_NOEXCEPT
2173  {
2174 #if __has_builtin(__builtin_nansq)
2175  return __builtin_nansq("");
2176 #elif __has_builtin(__builtin_bit_cast) && __has_builtin(__builtin_nansf128)
2177  return __builtin_bit_cast(__float128, __builtin_nansf128(""));
2178 #else
2179  return quiet_NaN();
2180 #endif
2181  }
2182 
2183  static _GLIBCXX_CONSTEXPR __float128
2184  denorm_min() _GLIBCXX_USE_NOEXCEPT
2185  {
2186 #if defined(__STRICT_ANSI__) || defined(__INTEL_COMPILER)
2187  // 0x1.0p-142 * 0x1.0p-16352
2188  return double(1.7936620343357659e-43) * _S_1pm16352();
2189 #else
2190  return __extension__ 0x1.0p-16494Q;
2191 #endif
2192  }
2193 
2194  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = has_signaling_NaN;
2195  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
2196  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
2197 
2198  static _GLIBCXX_USE_CONSTEXPR bool traps = false;
2199  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
2200  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
2201  = round_to_nearest;
2202 
2203 #if defined(__STRICT_ANSI__) || defined(__INTEL_COMPILER)
2204  private:
2205  static _GLIBCXX_CONSTEXPR __float128
2206  _S_4p(__float128 __v) _GLIBCXX_USE_NOEXCEPT
2207  { return __v * __v * __v * __v; }
2208 
2209  static _GLIBCXX_CONSTEXPR __float128
2210  _S_1pm4088() _GLIBCXX_USE_NOEXCEPT
2211  { return _S_4p(/* 0x1.0p-1022 */ double(2.2250738585072014e-308)); }
2212 
2213  static _GLIBCXX_CONSTEXPR __float128
2214  _S_1pm16352() _GLIBCXX_USE_NOEXCEPT
2215  { return _S_4p(_S_1pm4088()); }
2216 
2217  static _GLIBCXX_CONSTEXPR __float128
2218  _S_1p4064() _GLIBCXX_USE_NOEXCEPT
2219  { return _S_4p(/* 0x1.0p+1016 */ double(7.0222388080559215e+305)); }
2220 
2221  static _GLIBCXX_CONSTEXPR __float128
2222  _S_1p16256() _GLIBCXX_USE_NOEXCEPT
2223  { return _S_4p(_S_1p4064()); }
2224 #endif
2225  };
2226 #endif // !__STRICT_ANSI__ || DOUBLE_IS_IEEE_BINARY64
2227 #endif // _GLIBCXX_USE_FLOAT128
2228 
2229 _GLIBCXX_END_NAMESPACE_VERSION
2230 } // namespace
2231 
2232 #undef __glibcxx_signed
2233 #undef __glibcxx_min
2234 #undef __glibcxx_max
2235 #undef __glibcxx_digits
2236 #undef __glibcxx_digits10
2237 #undef __glibcxx_max_digits10
2238 
2239 #pragma GCC diagnostic pop
2240 #endif // _GLIBCXX_NUMERIC_LIMITS