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