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-2021 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10 
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15 
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19 
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
24 
25 /** @file include/limits
26  * This is a Standard C++ Library header.
27  */
28 
29 // Note: this is not a conforming implementation.
30 // Written by Gabriel Dos Reis <gdr@codesourcery.com>
31 
32 //
33 // ISO 14882:1998
34 // 18.2.1
35 //
36 
37 #ifndef _GLIBCXX_NUMERIC_LIMITS
38 #define _GLIBCXX_NUMERIC_LIMITS 1
39 
40 #pragma GCC system_header
41 
42 #include <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  */
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  */
183  {
184  /// Indeterminate at compile time whether denormalized values are allowed.
186  /// The type does not allow denormalized values.
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  */
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 =
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  template<typename _Tp>
313  {
314  /** The minimum finite value, or for floating types with
315  denormalization, the minimum positive normalized value. */
316  static _GLIBCXX_CONSTEXPR _Tp
317  min() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
318 
319  /** The maximum finite value. */
320  static _GLIBCXX_CONSTEXPR _Tp
321  max() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
322 
323 #if __cplusplus >= 201103L
324  /** A finite value x such that there is no other finite value y
325  * where y < x. */
326  static constexpr _Tp
327  lowest() noexcept { return _Tp(); }
328 #endif
329 
330  /** The @e machine @e epsilon: the difference between 1 and the least
331  value greater than 1 that is representable. */
332  static _GLIBCXX_CONSTEXPR _Tp
333  epsilon() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
334 
335  /** The maximum rounding error measurement (see LIA-1). */
336  static _GLIBCXX_CONSTEXPR _Tp
337  round_error() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
338 
339  /** The representation of positive infinity, if @c has_infinity. */
340  static _GLIBCXX_CONSTEXPR _Tp
341  infinity() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
342 
343  /** The representation of a quiet Not a Number,
344  if @c has_quiet_NaN. */
345  static _GLIBCXX_CONSTEXPR _Tp
346  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
347 
348  /** The representation of a signaling Not a Number, if
349  @c has_signaling_NaN. */
350  static _GLIBCXX_CONSTEXPR _Tp
351  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
352 
353  /** The minimum positive denormalized value. For types where
354  @c has_denorm is false, this is the minimum positive normalized
355  value. */
356  static _GLIBCXX_CONSTEXPR _Tp
357  denorm_min() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
358  };
359 
360  // _GLIBCXX_RESOLVE_LIB_DEFECTS
361  // 559. numeric_limits<const T>
362 
363  template<typename _Tp>
364  struct numeric_limits<const _Tp>
365  : public numeric_limits<_Tp> { };
366 
367  template<typename _Tp>
368  struct numeric_limits<volatile _Tp>
369  : public numeric_limits<_Tp> { };
370 
371  template<typename _Tp>
372  struct numeric_limits<const volatile _Tp>
373  : public numeric_limits<_Tp> { };
374 
375  // Now there follow 16 explicit specializations. Yes, 16. Make sure
376  // you get the count right. (18 in C++11 mode, with char16_t and char32_t.)
377  // (+1 if char8_t is enabled.)
378 
379  // _GLIBCXX_RESOLVE_LIB_DEFECTS
380  // 184. numeric_limits<bool> wording problems
381 
382  /// numeric_limits<bool> specialization.
383  template<>
384  struct numeric_limits<bool>
385  {
386  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
387 
388  static _GLIBCXX_CONSTEXPR bool
389  min() _GLIBCXX_USE_NOEXCEPT { return false; }
390 
391  static _GLIBCXX_CONSTEXPR bool
392  max() _GLIBCXX_USE_NOEXCEPT { return true; }
393 
394 #if __cplusplus >= 201103L
395  static constexpr bool
396  lowest() noexcept { return min(); }
397 #endif
398  static _GLIBCXX_USE_CONSTEXPR int digits = 1;
399  static _GLIBCXX_USE_CONSTEXPR int digits10 = 0;
400 #if __cplusplus >= 201103L
401  static constexpr int max_digits10 = 0;
402 #endif
403  static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
404  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
405  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
406  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
407 
408  static _GLIBCXX_CONSTEXPR bool
409  epsilon() _GLIBCXX_USE_NOEXCEPT { return false; }
410 
411  static _GLIBCXX_CONSTEXPR bool
412  round_error() _GLIBCXX_USE_NOEXCEPT { return false; }
413 
414  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
415  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
416  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
417  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
418 
419  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
420  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
421  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
422  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
423  = denorm_absent;
424  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
425 
426  static _GLIBCXX_CONSTEXPR bool
427  infinity() _GLIBCXX_USE_NOEXCEPT { return false; }
428 
429  static _GLIBCXX_CONSTEXPR bool
430  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return false; }
431 
432  static _GLIBCXX_CONSTEXPR bool
433  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return false; }
434 
435  static _GLIBCXX_CONSTEXPR bool
436  denorm_min() _GLIBCXX_USE_NOEXCEPT { return false; }
437 
438  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
439  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
440  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
441 
442  // It is not clear what it means for a boolean type to trap.
443  // This is a DR on the LWG issue list. Here, I use integer
444  // promotion semantics.
445  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
446  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
447  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
449  };
450 
451  /// numeric_limits<char> specialization.
452  template<>
453  struct numeric_limits<char>
454  {
455  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
456 
457  static _GLIBCXX_CONSTEXPR char
458  min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min(char); }
459 
460  static _GLIBCXX_CONSTEXPR char
461  max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max(char); }
462 
463 #if __cplusplus >= 201103L
464  static constexpr char
465  lowest() noexcept { return min(); }
466 #endif
467 
468  static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (char);
469  static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (char);
470 #if __cplusplus >= 201103L
471  static constexpr int max_digits10 = 0;
472 #endif
473  static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (char);
474  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
475  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
476  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
477 
478  static _GLIBCXX_CONSTEXPR char
479  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
480 
481  static _GLIBCXX_CONSTEXPR char
482  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
483 
484  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
485  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
486  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
487  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
488 
489  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
490  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
491  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
492  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
493  = denorm_absent;
494  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
495 
496  static _GLIBCXX_CONSTEXPR
497  char infinity() _GLIBCXX_USE_NOEXCEPT { return char(); }
498 
499  static _GLIBCXX_CONSTEXPR char
500  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return char(); }
501 
502  static _GLIBCXX_CONSTEXPR char
503  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return char(); }
504 
505  static _GLIBCXX_CONSTEXPR char
506  denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<char>(0); }
507 
508  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
509  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
510  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = !is_signed;
511 
512  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
513  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
514  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
516  };
517 
518  /// numeric_limits<signed char> specialization.
519  template<>
520  struct numeric_limits<signed char>
521  {
522  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
523 
524  static _GLIBCXX_CONSTEXPR signed char
525  min() _GLIBCXX_USE_NOEXCEPT { return -__SCHAR_MAX__ - 1; }
526 
527  static _GLIBCXX_CONSTEXPR signed char
528  max() _GLIBCXX_USE_NOEXCEPT { return __SCHAR_MAX__; }
529 
530 #if __cplusplus >= 201103L
531  static constexpr signed char
532  lowest() noexcept { return min(); }
533 #endif
534 
535  static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (signed char);
536  static _GLIBCXX_USE_CONSTEXPR int digits10
537  = __glibcxx_digits10 (signed char);
538 #if __cplusplus >= 201103L
539  static constexpr int max_digits10 = 0;
540 #endif
541  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
542  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
543  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
544  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
545 
546  static _GLIBCXX_CONSTEXPR signed char
547  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
548 
549  static _GLIBCXX_CONSTEXPR signed char
550  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
551 
552  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
553  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
554  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
555  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
556 
557  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
558  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
559  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
560  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
561  = denorm_absent;
562  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
563 
564  static _GLIBCXX_CONSTEXPR signed char
565  infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<signed char>(0); }
566 
567  static _GLIBCXX_CONSTEXPR signed char
568  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<signed char>(0); }
569 
570  static _GLIBCXX_CONSTEXPR signed char
571  signaling_NaN() _GLIBCXX_USE_NOEXCEPT
572  { return static_cast<signed char>(0); }
573 
574  static _GLIBCXX_CONSTEXPR signed char
575  denorm_min() _GLIBCXX_USE_NOEXCEPT
576  { return static_cast<signed char>(0); }
577 
578  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
579  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
580  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
581 
582  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
583  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
584  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
586  };
587 
588  /// numeric_limits<unsigned char> specialization.
589  template<>
590  struct numeric_limits<unsigned char>
591  {
592  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
593 
594  static _GLIBCXX_CONSTEXPR unsigned char
595  min() _GLIBCXX_USE_NOEXCEPT { return 0; }
596 
597  static _GLIBCXX_CONSTEXPR unsigned char
598  max() _GLIBCXX_USE_NOEXCEPT { return __SCHAR_MAX__ * 2U + 1; }
599 
600 #if __cplusplus >= 201103L
601  static constexpr unsigned char
602  lowest() noexcept { return min(); }
603 #endif
604 
605  static _GLIBCXX_USE_CONSTEXPR int digits
606  = __glibcxx_digits (unsigned char);
607  static _GLIBCXX_USE_CONSTEXPR int digits10
608  = __glibcxx_digits10 (unsigned char);
609 #if __cplusplus >= 201103L
610  static constexpr int max_digits10 = 0;
611 #endif
612  static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
613  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
614  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
615  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
616 
617  static _GLIBCXX_CONSTEXPR unsigned char
618  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
619 
620  static _GLIBCXX_CONSTEXPR unsigned char
621  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
622 
623  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
624  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
625  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
626  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
627 
628  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
629  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
630  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
631  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
632  = denorm_absent;
633  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
634 
635  static _GLIBCXX_CONSTEXPR unsigned char
636  infinity() _GLIBCXX_USE_NOEXCEPT
637  { return static_cast<unsigned char>(0); }
638 
639  static _GLIBCXX_CONSTEXPR unsigned char
640  quiet_NaN() _GLIBCXX_USE_NOEXCEPT
641  { return static_cast<unsigned char>(0); }
642 
643  static _GLIBCXX_CONSTEXPR unsigned char
644  signaling_NaN() _GLIBCXX_USE_NOEXCEPT
645  { return static_cast<unsigned char>(0); }
646 
647  static _GLIBCXX_CONSTEXPR unsigned char
648  denorm_min() _GLIBCXX_USE_NOEXCEPT
649  { return static_cast<unsigned char>(0); }
650 
651  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
652  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
653  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
654 
655  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
656  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
657  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
659  };
660 
661  /// numeric_limits<wchar_t> specialization.
662  template<>
663  struct numeric_limits<wchar_t>
664  {
665  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
666 
667  static _GLIBCXX_CONSTEXPR wchar_t
668  min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min (wchar_t); }
669 
670  static _GLIBCXX_CONSTEXPR wchar_t
671  max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max (wchar_t); }
672 
673 #if __cplusplus >= 201103L
674  static constexpr wchar_t
675  lowest() noexcept { return min(); }
676 #endif
677 
678  static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (wchar_t);
679  static _GLIBCXX_USE_CONSTEXPR int digits10
680  = __glibcxx_digits10 (wchar_t);
681 #if __cplusplus >= 201103L
682  static constexpr int max_digits10 = 0;
683 #endif
684  static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (wchar_t);
685  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
686  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
687  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
688 
689  static _GLIBCXX_CONSTEXPR wchar_t
690  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
691 
692  static _GLIBCXX_CONSTEXPR wchar_t
693  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
694 
695  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
696  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
697  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
698  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
699 
700  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
701  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
702  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
703  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
704  = denorm_absent;
705  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
706 
707  static _GLIBCXX_CONSTEXPR wchar_t
708  infinity() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
709 
710  static _GLIBCXX_CONSTEXPR wchar_t
711  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
712 
713  static _GLIBCXX_CONSTEXPR wchar_t
714  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
715 
716  static _GLIBCXX_CONSTEXPR wchar_t
717  denorm_min() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
718 
719  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
720  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
721  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = !is_signed;
722 
723  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
724  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
725  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
727  };
728 
729 #if _GLIBCXX_USE_CHAR8_T
730  /// numeric_limits<char8_t> specialization.
731  template<>
732  struct numeric_limits<char8_t>
733  {
734  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
735 
736  static _GLIBCXX_CONSTEXPR char8_t
737  min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min (char8_t); }
738 
739  static _GLIBCXX_CONSTEXPR char8_t
740  max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max (char8_t); }
741 
742  static _GLIBCXX_CONSTEXPR char8_t
743  lowest() _GLIBCXX_USE_NOEXCEPT { return min(); }
744 
745  static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (char8_t);
746  static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (char8_t);
747  static _GLIBCXX_USE_CONSTEXPR int max_digits10 = 0;
748  static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (char8_t);
749  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
750  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
751  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
752 
753  static _GLIBCXX_CONSTEXPR char8_t
754  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
755 
756  static _GLIBCXX_CONSTEXPR char8_t
757  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
758 
759  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
760  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
761  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
762  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
763 
764  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
765  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
766  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
767  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
768  = denorm_absent;
769  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
770 
771  static _GLIBCXX_CONSTEXPR char8_t
772  infinity() _GLIBCXX_USE_NOEXCEPT { return char8_t(); }
773 
774  static _GLIBCXX_CONSTEXPR char8_t
775  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return char8_t(); }
776 
777  static _GLIBCXX_CONSTEXPR char8_t
778  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return char8_t(); }
779 
780  static _GLIBCXX_CONSTEXPR char8_t
781  denorm_min() _GLIBCXX_USE_NOEXCEPT { return char8_t(); }
782 
783  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
784  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
785  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = !is_signed;
786 
787  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
788  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
789  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
791  };
792 #endif
793 
794 #if __cplusplus >= 201103L
795  /// numeric_limits<char16_t> specialization.
796  template<>
797  struct numeric_limits<char16_t>
798  {
799  static constexpr bool is_specialized = true;
800 
801  static constexpr char16_t
802  min() noexcept { return __glibcxx_min (char16_t); }
803 
804  static constexpr char16_t
805  max() noexcept { return __glibcxx_max (char16_t); }
806 
807  static constexpr char16_t
808  lowest() noexcept { return min(); }
809 
810  static constexpr int digits = __glibcxx_digits (char16_t);
811  static constexpr int digits10 = __glibcxx_digits10 (char16_t);
812  static constexpr int max_digits10 = 0;
813  static constexpr bool is_signed = __glibcxx_signed (char16_t);
814  static constexpr bool is_integer = true;
815  static constexpr bool is_exact = true;
816  static constexpr int radix = 2;
817 
818  static constexpr char16_t
819  epsilon() noexcept { return 0; }
820 
821  static constexpr char16_t
822  round_error() noexcept { return 0; }
823 
824  static constexpr int min_exponent = 0;
825  static constexpr int min_exponent10 = 0;
826  static constexpr int max_exponent = 0;
827  static constexpr int max_exponent10 = 0;
828 
829  static constexpr bool has_infinity = false;
830  static constexpr bool has_quiet_NaN = false;
831  static constexpr bool has_signaling_NaN = false;
832  static constexpr float_denorm_style has_denorm = denorm_absent;
833  static constexpr bool has_denorm_loss = false;
834 
835  static constexpr char16_t
836  infinity() noexcept { return char16_t(); }
837 
838  static constexpr char16_t
839  quiet_NaN() noexcept { return char16_t(); }
840 
841  static constexpr char16_t
842  signaling_NaN() noexcept { return char16_t(); }
843 
844  static constexpr char16_t
845  denorm_min() noexcept { return char16_t(); }
846 
847  static constexpr bool is_iec559 = false;
848  static constexpr bool is_bounded = true;
849  static constexpr bool is_modulo = !is_signed;
850 
851  static constexpr bool traps = __glibcxx_integral_traps;
852  static constexpr bool tinyness_before = false;
854  };
855 
856  /// numeric_limits<char32_t> specialization.
857  template<>
858  struct numeric_limits<char32_t>
859  {
860  static constexpr bool is_specialized = true;
861 
862  static constexpr char32_t
863  min() noexcept { return __glibcxx_min (char32_t); }
864 
865  static constexpr char32_t
866  max() noexcept { return __glibcxx_max (char32_t); }
867 
868  static constexpr char32_t
869  lowest() noexcept { return min(); }
870 
871  static constexpr int digits = __glibcxx_digits (char32_t);
872  static constexpr int digits10 = __glibcxx_digits10 (char32_t);
873  static constexpr int max_digits10 = 0;
874  static constexpr bool is_signed = __glibcxx_signed (char32_t);
875  static constexpr bool is_integer = true;
876  static constexpr bool is_exact = true;
877  static constexpr int radix = 2;
878 
879  static constexpr char32_t
880  epsilon() noexcept { return 0; }
881 
882  static constexpr char32_t
883  round_error() noexcept { return 0; }
884 
885  static constexpr int min_exponent = 0;
886  static constexpr int min_exponent10 = 0;
887  static constexpr int max_exponent = 0;
888  static constexpr int max_exponent10 = 0;
889 
890  static constexpr bool has_infinity = false;
891  static constexpr bool has_quiet_NaN = false;
892  static constexpr bool has_signaling_NaN = false;
893  static constexpr float_denorm_style has_denorm = denorm_absent;
894  static constexpr bool has_denorm_loss = false;
895 
896  static constexpr char32_t
897  infinity() noexcept { return char32_t(); }
898 
899  static constexpr char32_t
900  quiet_NaN() noexcept { return char32_t(); }
901 
902  static constexpr char32_t
903  signaling_NaN() noexcept { return char32_t(); }
904 
905  static constexpr char32_t
906  denorm_min() noexcept { return char32_t(); }
907 
908  static constexpr bool is_iec559 = false;
909  static constexpr bool is_bounded = true;
910  static constexpr bool is_modulo = !is_signed;
911 
912  static constexpr bool traps = __glibcxx_integral_traps;
913  static constexpr bool tinyness_before = false;
915  };
916 #endif
917 
918  /// numeric_limits<short> specialization.
919  template<>
920  struct numeric_limits<short>
921  {
922  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
923 
924  static _GLIBCXX_CONSTEXPR short
925  min() _GLIBCXX_USE_NOEXCEPT { return -__SHRT_MAX__ - 1; }
926 
927  static _GLIBCXX_CONSTEXPR short
928  max() _GLIBCXX_USE_NOEXCEPT { return __SHRT_MAX__; }
929 
930 #if __cplusplus >= 201103L
931  static constexpr short
932  lowest() noexcept { return min(); }
933 #endif
934 
935  static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (short);
936  static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (short);
937 #if __cplusplus >= 201103L
938  static constexpr int max_digits10 = 0;
939 #endif
940  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
941  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
942  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
943  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
944 
945  static _GLIBCXX_CONSTEXPR short
946  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
947 
948  static _GLIBCXX_CONSTEXPR short
949  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
950 
951  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
952  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
953  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
954  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
955 
956  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
957  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
958  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
959  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
960  = denorm_absent;
961  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
962 
963  static _GLIBCXX_CONSTEXPR short
964  infinity() _GLIBCXX_USE_NOEXCEPT { return short(); }
965 
966  static _GLIBCXX_CONSTEXPR short
967  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return short(); }
968 
969  static _GLIBCXX_CONSTEXPR short
970  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return short(); }
971 
972  static _GLIBCXX_CONSTEXPR short
973  denorm_min() _GLIBCXX_USE_NOEXCEPT { return short(); }
974 
975  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
976  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
977  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
978 
979  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
980  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
981  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
983  };
984 
985  /// numeric_limits<unsigned short> specialization.
986  template<>
987  struct numeric_limits<unsigned short>
988  {
989  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
990 
991  static _GLIBCXX_CONSTEXPR unsigned short
992  min() _GLIBCXX_USE_NOEXCEPT { return 0; }
993 
994  static _GLIBCXX_CONSTEXPR unsigned short
995  max() _GLIBCXX_USE_NOEXCEPT { return __SHRT_MAX__ * 2U + 1; }
996 
997 #if __cplusplus >= 201103L
998  static constexpr unsigned short
999  lowest() noexcept { return min(); }
1000 #endif
1001 
1002  static _GLIBCXX_USE_CONSTEXPR int digits
1003  = __glibcxx_digits (unsigned short);
1004  static _GLIBCXX_USE_CONSTEXPR int digits10
1005  = __glibcxx_digits10 (unsigned short);
1006 #if __cplusplus >= 201103L
1007  static constexpr int max_digits10 = 0;
1008 #endif
1009  static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
1010  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1011  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1012  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1013 
1014  static _GLIBCXX_CONSTEXPR unsigned short
1015  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1016 
1017  static _GLIBCXX_CONSTEXPR unsigned short
1018  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1019 
1020  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1021  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1022  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1023  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1024 
1025  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1026  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1027  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1028  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1029  = denorm_absent;
1030  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1031 
1032  static _GLIBCXX_CONSTEXPR unsigned short
1033  infinity() _GLIBCXX_USE_NOEXCEPT
1034  { return static_cast<unsigned short>(0); }
1035 
1036  static _GLIBCXX_CONSTEXPR unsigned short
1037  quiet_NaN() _GLIBCXX_USE_NOEXCEPT
1038  { return static_cast<unsigned short>(0); }
1039 
1040  static _GLIBCXX_CONSTEXPR unsigned short
1041  signaling_NaN() _GLIBCXX_USE_NOEXCEPT
1042  { return static_cast<unsigned short>(0); }
1043 
1044  static _GLIBCXX_CONSTEXPR unsigned short
1045  denorm_min() _GLIBCXX_USE_NOEXCEPT
1046  { return static_cast<unsigned short>(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 = true;
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
1056  };
1057 
1058  /// numeric_limits<int> specialization.
1059  template<>
1060  struct numeric_limits<int>
1061  {
1062  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1063 
1064  static _GLIBCXX_CONSTEXPR int
1065  min() _GLIBCXX_USE_NOEXCEPT { return -__INT_MAX__ - 1; }
1066 
1067  static _GLIBCXX_CONSTEXPR int
1068  max() _GLIBCXX_USE_NOEXCEPT { return __INT_MAX__; }
1069 
1070 #if __cplusplus >= 201103L
1071  static constexpr int
1072  lowest() noexcept { return min(); }
1073 #endif
1074 
1075  static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (int);
1076  static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (int);
1077 #if __cplusplus >= 201103L
1078  static constexpr int max_digits10 = 0;
1079 #endif
1080  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1081  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1082  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1083  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1084 
1085  static _GLIBCXX_CONSTEXPR int
1086  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1087 
1088  static _GLIBCXX_CONSTEXPR int
1089  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1090 
1091  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1092  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1093  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1094  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1095 
1096  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1097  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1098  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1099  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1100  = denorm_absent;
1101  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1102 
1103  static _GLIBCXX_CONSTEXPR int
1104  infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
1105 
1106  static _GLIBCXX_CONSTEXPR int
1107  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
1108 
1109  static _GLIBCXX_CONSTEXPR int
1110  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
1111 
1112  static _GLIBCXX_CONSTEXPR int
1113  denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
1114 
1115  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1116  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1117  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1118 
1119  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1120  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1121  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1123  };
1124 
1125  /// numeric_limits<unsigned int> specialization.
1126  template<>
1127  struct numeric_limits<unsigned int>
1128  {
1129  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1130 
1131  static _GLIBCXX_CONSTEXPR unsigned int
1132  min() _GLIBCXX_USE_NOEXCEPT { return 0; }
1133 
1134  static _GLIBCXX_CONSTEXPR unsigned int
1135  max() _GLIBCXX_USE_NOEXCEPT { return __INT_MAX__ * 2U + 1; }
1136 
1137 #if __cplusplus >= 201103L
1138  static constexpr unsigned int
1139  lowest() noexcept { return min(); }
1140 #endif
1141 
1142  static _GLIBCXX_USE_CONSTEXPR int digits
1143  = __glibcxx_digits (unsigned int);
1144  static _GLIBCXX_USE_CONSTEXPR int digits10
1145  = __glibcxx_digits10 (unsigned int);
1146 #if __cplusplus >= 201103L
1147  static constexpr int max_digits10 = 0;
1148 #endif
1149  static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
1150  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1151  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1152  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1153 
1154  static _GLIBCXX_CONSTEXPR unsigned int
1155  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1156 
1157  static _GLIBCXX_CONSTEXPR unsigned int
1158  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1159 
1160  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1161  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1162  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1163  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1164 
1165  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1166  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1167  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1168  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1169  = denorm_absent;
1170  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1171 
1172  static _GLIBCXX_CONSTEXPR unsigned int
1173  infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<unsigned int>(0); }
1174 
1175  static _GLIBCXX_CONSTEXPR unsigned int
1176  quiet_NaN() _GLIBCXX_USE_NOEXCEPT
1177  { return static_cast<unsigned int>(0); }
1178 
1179  static _GLIBCXX_CONSTEXPR unsigned int
1180  signaling_NaN() _GLIBCXX_USE_NOEXCEPT
1181  { return static_cast<unsigned int>(0); }
1182 
1183  static _GLIBCXX_CONSTEXPR unsigned int
1184  denorm_min() _GLIBCXX_USE_NOEXCEPT
1185  { return static_cast<unsigned int>(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 = true;
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
1195  };
1196 
1197  /// numeric_limits<long> specialization.
1198  template<>
1199  struct numeric_limits<long>
1200  {
1201  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1202 
1203  static _GLIBCXX_CONSTEXPR long
1204  min() _GLIBCXX_USE_NOEXCEPT { return -__LONG_MAX__ - 1; }
1205 
1206  static _GLIBCXX_CONSTEXPR long
1207  max() _GLIBCXX_USE_NOEXCEPT { return __LONG_MAX__; }
1208 
1209 #if __cplusplus >= 201103L
1210  static constexpr long
1211  lowest() noexcept { return min(); }
1212 #endif
1213 
1214  static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (long);
1215  static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (long);
1216 #if __cplusplus >= 201103L
1217  static constexpr int max_digits10 = 0;
1218 #endif
1219  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1220  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1221  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1222  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1223 
1224  static _GLIBCXX_CONSTEXPR long
1225  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1226 
1227  static _GLIBCXX_CONSTEXPR long
1228  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1229 
1230  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1231  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1232  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1233  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1234 
1235  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1236  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1237  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1238  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1239  = denorm_absent;
1240  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1241 
1242  static _GLIBCXX_CONSTEXPR long
1243  infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
1244 
1245  static _GLIBCXX_CONSTEXPR long
1246  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
1247 
1248  static _GLIBCXX_CONSTEXPR long
1249  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
1250 
1251  static _GLIBCXX_CONSTEXPR long
1252  denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
1253 
1254  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1255  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1256  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1257 
1258  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1259  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1260  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1262  };
1263 
1264  /// numeric_limits<unsigned long> specialization.
1265  template<>
1266  struct numeric_limits<unsigned long>
1267  {
1268  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1269 
1270  static _GLIBCXX_CONSTEXPR unsigned long
1271  min() _GLIBCXX_USE_NOEXCEPT { return 0; }
1272 
1273  static _GLIBCXX_CONSTEXPR unsigned long
1274  max() _GLIBCXX_USE_NOEXCEPT { return __LONG_MAX__ * 2UL + 1; }
1275 
1276 #if __cplusplus >= 201103L
1277  static constexpr unsigned long
1278  lowest() noexcept { return min(); }
1279 #endif
1280 
1281  static _GLIBCXX_USE_CONSTEXPR int digits
1282  = __glibcxx_digits (unsigned long);
1283  static _GLIBCXX_USE_CONSTEXPR int digits10
1284  = __glibcxx_digits10 (unsigned long);
1285 #if __cplusplus >= 201103L
1286  static constexpr int max_digits10 = 0;
1287 #endif
1288  static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
1289  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1290  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1291  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1292 
1293  static _GLIBCXX_CONSTEXPR unsigned long
1294  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1295 
1296  static _GLIBCXX_CONSTEXPR unsigned long
1297  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1298 
1299  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1300  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1301  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1302  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1303 
1304  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1305  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1306  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1307  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1308  = denorm_absent;
1309  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1310 
1311  static _GLIBCXX_CONSTEXPR unsigned long
1312  infinity() _GLIBCXX_USE_NOEXCEPT
1313  { return static_cast<unsigned long>(0); }
1314 
1315  static _GLIBCXX_CONSTEXPR unsigned long
1316  quiet_NaN() _GLIBCXX_USE_NOEXCEPT
1317  { return static_cast<unsigned long>(0); }
1318 
1319  static _GLIBCXX_CONSTEXPR unsigned long
1320  signaling_NaN() _GLIBCXX_USE_NOEXCEPT
1321  { return static_cast<unsigned long>(0); }
1322 
1323  static _GLIBCXX_CONSTEXPR unsigned long
1324  denorm_min() _GLIBCXX_USE_NOEXCEPT
1325  { return static_cast<unsigned long>(0); }
1326 
1327  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1328  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1329  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1330 
1331  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1332  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1333  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1335  };
1336 
1337  /// numeric_limits<long long> specialization.
1338  template<>
1339  struct numeric_limits<long long>
1340  {
1341  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1342 
1343  static _GLIBCXX_CONSTEXPR long long
1344  min() _GLIBCXX_USE_NOEXCEPT { return -__LONG_LONG_MAX__ - 1; }
1345 
1346  static _GLIBCXX_CONSTEXPR long long
1347  max() _GLIBCXX_USE_NOEXCEPT { return __LONG_LONG_MAX__; }
1348 
1349 #if __cplusplus >= 201103L
1350  static constexpr long long
1351  lowest() noexcept { return min(); }
1352 #endif
1353 
1354  static _GLIBCXX_USE_CONSTEXPR int digits
1355  = __glibcxx_digits (long long);
1356  static _GLIBCXX_USE_CONSTEXPR int digits10
1357  = __glibcxx_digits10 (long long);
1358 #if __cplusplus >= 201103L
1359  static constexpr int max_digits10 = 0;
1360 #endif
1361  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1362  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1363  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1364  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1365 
1366  static _GLIBCXX_CONSTEXPR long long
1367  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1368 
1369  static _GLIBCXX_CONSTEXPR long long
1370  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1371 
1372  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1373  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1374  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1375  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1376 
1377  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1378  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1379  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1380  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1381  = denorm_absent;
1382  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1383 
1384  static _GLIBCXX_CONSTEXPR long long
1385  infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); }
1386 
1387  static _GLIBCXX_CONSTEXPR long long
1388  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); }
1389 
1390  static _GLIBCXX_CONSTEXPR long long
1391  signaling_NaN() _GLIBCXX_USE_NOEXCEPT
1392  { return static_cast<long long>(0); }
1393 
1394  static _GLIBCXX_CONSTEXPR long long
1395  denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); }
1396 
1397  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1398  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1399  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1400 
1401  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1402  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1403  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1405  };
1406 
1407  /// numeric_limits<unsigned long long> specialization.
1408  template<>
1409  struct numeric_limits<unsigned long long>
1410  {
1411  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1412 
1413  static _GLIBCXX_CONSTEXPR unsigned long long
1414  min() _GLIBCXX_USE_NOEXCEPT { return 0; }
1415 
1416  static _GLIBCXX_CONSTEXPR unsigned long long
1417  max() _GLIBCXX_USE_NOEXCEPT { return __LONG_LONG_MAX__ * 2ULL + 1; }
1418 
1419 #if __cplusplus >= 201103L
1420  static constexpr unsigned long long
1421  lowest() noexcept { return min(); }
1422 #endif
1423 
1424  static _GLIBCXX_USE_CONSTEXPR int digits
1425  = __glibcxx_digits (unsigned long long);
1426  static _GLIBCXX_USE_CONSTEXPR int digits10
1427  = __glibcxx_digits10 (unsigned long long);
1428 #if __cplusplus >= 201103L
1429  static constexpr int max_digits10 = 0;
1430 #endif
1431  static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
1432  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1433  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1434  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1435 
1436  static _GLIBCXX_CONSTEXPR unsigned long long
1437  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1438 
1439  static _GLIBCXX_CONSTEXPR unsigned long long
1440  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1441 
1442  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1443  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1444  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1445  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1446 
1447  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1448  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1449  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1450  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1451  = denorm_absent;
1452  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1453 
1454  static _GLIBCXX_CONSTEXPR unsigned long long
1455  infinity() _GLIBCXX_USE_NOEXCEPT
1456  { return static_cast<unsigned long long>(0); }
1457 
1458  static _GLIBCXX_CONSTEXPR unsigned long long
1459  quiet_NaN() _GLIBCXX_USE_NOEXCEPT
1460  { return static_cast<unsigned long long>(0); }
1461 
1462  static _GLIBCXX_CONSTEXPR unsigned long long
1463  signaling_NaN() _GLIBCXX_USE_NOEXCEPT
1464  { return static_cast<unsigned long long>(0); }
1465 
1466  static _GLIBCXX_CONSTEXPR unsigned long long
1467  denorm_min() _GLIBCXX_USE_NOEXCEPT
1468  { return static_cast<unsigned long long>(0); }
1469 
1470  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1471  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1472  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1473 
1474  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1475  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1476  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1478  };
1479 
1480 #define __INT_N(TYPE, BITSIZE, EXT, UEXT) \
1481  template<> \
1482  struct numeric_limits<TYPE> \
1483  { \
1484  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; \
1485  \
1486  static _GLIBCXX_CONSTEXPR TYPE \
1487  min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min_b (TYPE, BITSIZE); } \
1488  \
1489  static _GLIBCXX_CONSTEXPR TYPE \
1490  max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max_b (TYPE, BITSIZE); } \
1491  \
1492  static _GLIBCXX_USE_CONSTEXPR int digits \
1493  = BITSIZE - 1; \
1494  static _GLIBCXX_USE_CONSTEXPR int digits10 \
1495  = (BITSIZE - 1) * 643L / 2136; \
1496  \
1497  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; \
1498  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; \
1499  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; \
1500  static _GLIBCXX_USE_CONSTEXPR int radix = 2; \
1501  \
1502  static _GLIBCXX_CONSTEXPR TYPE \
1503  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } \
1504  \
1505  static _GLIBCXX_CONSTEXPR TYPE \
1506  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } \
1507  \
1508  EXT \
1509  \
1510  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; \
1511  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; \
1512  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; \
1513  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; \
1514  \
1515  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; \
1516  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; \
1517  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; \
1518  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm \
1519  = denorm_absent; \
1520  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; \
1521  \
1522  static _GLIBCXX_CONSTEXPR TYPE \
1523  infinity() _GLIBCXX_USE_NOEXCEPT \
1524  { return static_cast<TYPE>(0); } \
1525  \
1526  static _GLIBCXX_CONSTEXPR TYPE \
1527  quiet_NaN() _GLIBCXX_USE_NOEXCEPT \
1528  { return static_cast<TYPE>(0); } \
1529  \
1530  static _GLIBCXX_CONSTEXPR TYPE \
1531  signaling_NaN() _GLIBCXX_USE_NOEXCEPT \
1532  { return static_cast<TYPE>(0); } \
1533  \
1534  static _GLIBCXX_CONSTEXPR TYPE \
1535  denorm_min() _GLIBCXX_USE_NOEXCEPT \
1536  { return static_cast<TYPE>(0); } \
1537  \
1538  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; \
1539  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; \
1540  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; \
1541  \
1542  static _GLIBCXX_USE_CONSTEXPR bool traps \
1543  = __glibcxx_integral_traps; \
1544  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; \
1545  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style \
1546  = round_toward_zero; \
1547  }; \
1548  \
1549  template<> \
1550  struct numeric_limits<unsigned TYPE> \
1551  { \
1552  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; \
1553  \
1554  static _GLIBCXX_CONSTEXPR unsigned TYPE \
1555  min() _GLIBCXX_USE_NOEXCEPT { return 0; } \
1556  \
1557  static _GLIBCXX_CONSTEXPR unsigned TYPE \
1558  max() _GLIBCXX_USE_NOEXCEPT \
1559  { return __glibcxx_max_b (unsigned TYPE, BITSIZE); } \
1560  \
1561  UEXT \
1562  \
1563  static _GLIBCXX_USE_CONSTEXPR int digits \
1564  = BITSIZE; \
1565  static _GLIBCXX_USE_CONSTEXPR int digits10 \
1566  = BITSIZE * 643L / 2136; \
1567  static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; \
1568  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; \
1569  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; \
1570  static _GLIBCXX_USE_CONSTEXPR int radix = 2; \
1571  \
1572  static _GLIBCXX_CONSTEXPR unsigned TYPE \
1573  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } \
1574  \
1575  static _GLIBCXX_CONSTEXPR unsigned TYPE \
1576  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } \
1577  \
1578  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; \
1579  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; \
1580  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; \
1581  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; \
1582  \
1583  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; \
1584  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; \
1585  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; \
1586  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm \
1587  = denorm_absent; \
1588  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; \
1589  \
1590  static _GLIBCXX_CONSTEXPR unsigned TYPE \
1591  infinity() _GLIBCXX_USE_NOEXCEPT \
1592  { return static_cast<unsigned TYPE>(0); } \
1593  \
1594  static _GLIBCXX_CONSTEXPR unsigned TYPE \
1595  quiet_NaN() _GLIBCXX_USE_NOEXCEPT \
1596  { return static_cast<unsigned TYPE>(0); } \
1597  \
1598  static _GLIBCXX_CONSTEXPR unsigned TYPE \
1599  signaling_NaN() _GLIBCXX_USE_NOEXCEPT \
1600  { return static_cast<unsigned TYPE>(0); } \
1601  \
1602  static _GLIBCXX_CONSTEXPR unsigned TYPE \
1603  denorm_min() _GLIBCXX_USE_NOEXCEPT \
1604  { return static_cast<unsigned TYPE>(0); } \
1605  \
1606  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; \
1607  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; \
1608  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; \
1609  \
1610  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; \
1611  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; \
1612  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style \
1613  = round_toward_zero; \
1614  };
1615 
1616 #if __cplusplus >= 201103L
1617 
1618 #define __INT_N_201103(TYPE) \
1619  static constexpr TYPE \
1620  lowest() noexcept { return min(); } \
1621  static constexpr int max_digits10 = 0;
1622 
1623 #define __INT_N_U201103(TYPE) \
1624  static constexpr unsigned TYPE \
1625  lowest() noexcept { return min(); } \
1626  static constexpr int max_digits10 = 0;
1627 
1628 #else
1629 #define __INT_N_201103(TYPE)
1630 #define __INT_N_U201103(TYPE)
1631 #endif
1632 
1633 #if !defined(__STRICT_ANSI__)
1634 #ifdef __GLIBCXX_TYPE_INT_N_0
1635  __INT_N(__GLIBCXX_TYPE_INT_N_0, __GLIBCXX_BITSIZE_INT_N_0,
1636  __INT_N_201103 (__GLIBCXX_TYPE_INT_N_0),
1637  __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_0))
1638 #endif
1639 #ifdef __GLIBCXX_TYPE_INT_N_1
1640  __INT_N (__GLIBCXX_TYPE_INT_N_1, __GLIBCXX_BITSIZE_INT_N_1,
1641  __INT_N_201103 (__GLIBCXX_TYPE_INT_N_1),
1642  __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_1))
1643 #endif
1644 #ifdef __GLIBCXX_TYPE_INT_N_2
1645  __INT_N (__GLIBCXX_TYPE_INT_N_2, __GLIBCXX_BITSIZE_INT_N_2,
1646  __INT_N_201103 (__GLIBCXX_TYPE_INT_N_2),
1647  __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_2))
1648 #endif
1649 #ifdef __GLIBCXX_TYPE_INT_N_3
1650  __INT_N (__GLIBCXX_TYPE_INT_N_3, __GLIBCXX_BITSIZE_INT_N_3,
1651  __INT_N_201103 (__GLIBCXX_TYPE_INT_N_3),
1652  __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_3))
1653 #endif
1654 
1655 #elif defined __STRICT_ANSI__ && defined __SIZEOF_INT128__
1656  __INT_N(__int128, 128,
1657  __INT_N_201103 (__int128),
1658  __INT_N_U201103 (__int128))
1659 #endif
1660 
1661 #undef __INT_N
1662 #undef __INT_N_201103
1663 #undef __INT_N_U201103
1664 
1665 
1666  /// numeric_limits<float> specialization.
1667  template<>
1668  struct numeric_limits<float>
1669  {
1670  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1671 
1672  static _GLIBCXX_CONSTEXPR float
1673  min() _GLIBCXX_USE_NOEXCEPT { return __FLT_MIN__; }
1674 
1675  static _GLIBCXX_CONSTEXPR float
1676  max() _GLIBCXX_USE_NOEXCEPT { return __FLT_MAX__; }
1677 
1678 #if __cplusplus >= 201103L
1679  static constexpr float
1680  lowest() noexcept { return -__FLT_MAX__; }
1681 #endif
1682 
1683  static _GLIBCXX_USE_CONSTEXPR int digits = __FLT_MANT_DIG__;
1684  static _GLIBCXX_USE_CONSTEXPR int digits10 = __FLT_DIG__;
1685 #if __cplusplus >= 201103L
1686  static constexpr int max_digits10
1687  = __glibcxx_max_digits10 (__FLT_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 float
1695  epsilon() _GLIBCXX_USE_NOEXCEPT { return __FLT_EPSILON__; }
1696 
1697  static _GLIBCXX_CONSTEXPR float
1698  round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5F; }
1699 
1700  static _GLIBCXX_USE_CONSTEXPR int min_exponent = __FLT_MIN_EXP__;
1701  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __FLT_MIN_10_EXP__;
1702  static _GLIBCXX_USE_CONSTEXPR int max_exponent = __FLT_MAX_EXP__;
1703  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __FLT_MAX_10_EXP__;
1704 
1705  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __FLT_HAS_INFINITY__;
1706  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __FLT_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(__FLT_HAS_DENORM__) ? denorm_present : denorm_absent;
1710  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
1711  = __glibcxx_float_has_denorm_loss;
1712 
1713  static _GLIBCXX_CONSTEXPR float
1714  infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_valf(); }
1715 
1716  static _GLIBCXX_CONSTEXPR float
1717  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nanf(""); }
1718 
1719  static _GLIBCXX_CONSTEXPR float
1720  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nansf(""); }
1721 
1722  static _GLIBCXX_CONSTEXPR float
1723  denorm_min() _GLIBCXX_USE_NOEXCEPT { return __FLT_DENORM_MIN__; }
1724 
1725  static _GLIBCXX_USE_CONSTEXPR bool is_iec559
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_float_traps;
1731  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before
1732  = __glibcxx_float_tinyness_before;
1733  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1734  = round_to_nearest;
1735  };
1736 
1737 #undef __glibcxx_float_has_denorm_loss
1738 #undef __glibcxx_float_traps
1739 #undef __glibcxx_float_tinyness_before
1740 
1741  /// numeric_limits<double> specialization.
1742  template<>
1743  struct numeric_limits<double>
1744  {
1745  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1746 
1747  static _GLIBCXX_CONSTEXPR double
1748  min() _GLIBCXX_USE_NOEXCEPT { return __DBL_MIN__; }
1749 
1750  static _GLIBCXX_CONSTEXPR double
1751  max() _GLIBCXX_USE_NOEXCEPT { return __DBL_MAX__; }
1752 
1753 #if __cplusplus >= 201103L
1754  static constexpr double
1755  lowest() noexcept { return -__DBL_MAX__; }
1756 #endif
1757 
1758  static _GLIBCXX_USE_CONSTEXPR int digits = __DBL_MANT_DIG__;
1759  static _GLIBCXX_USE_CONSTEXPR int digits10 = __DBL_DIG__;
1760 #if __cplusplus >= 201103L
1761  static constexpr int max_digits10
1762  = __glibcxx_max_digits10 (__DBL_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 double
1770  epsilon() _GLIBCXX_USE_NOEXCEPT { return __DBL_EPSILON__; }
1771 
1772  static _GLIBCXX_CONSTEXPR double
1773  round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5; }
1774 
1775  static _GLIBCXX_USE_CONSTEXPR int min_exponent = __DBL_MIN_EXP__;
1776  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __DBL_MIN_10_EXP__;
1777  static _GLIBCXX_USE_CONSTEXPR int max_exponent = __DBL_MAX_EXP__;
1778  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __DBL_MAX_10_EXP__;
1779 
1780  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __DBL_HAS_INFINITY__;
1781  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __DBL_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(__DBL_HAS_DENORM__) ? denorm_present : denorm_absent;
1785  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
1786  = __glibcxx_double_has_denorm_loss;
1787 
1788  static _GLIBCXX_CONSTEXPR double
1789  infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_val(); }
1790 
1791  static _GLIBCXX_CONSTEXPR double
1792  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nan(""); }
1793 
1794  static _GLIBCXX_CONSTEXPR double
1795  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nans(""); }
1796 
1797  static _GLIBCXX_CONSTEXPR double
1798  denorm_min() _GLIBCXX_USE_NOEXCEPT { return __DBL_DENORM_MIN__; }
1799 
1800  static _GLIBCXX_USE_CONSTEXPR bool is_iec559
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_double_traps;
1806  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before
1807  = __glibcxx_double_tinyness_before;
1808  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1809  = round_to_nearest;
1810  };
1811 
1812 #undef __glibcxx_double_has_denorm_loss
1813 #undef __glibcxx_double_traps
1814 #undef __glibcxx_double_tinyness_before
1815 
1816  /// numeric_limits<long double> specialization.
1817  template<>
1818  struct numeric_limits<long double>
1819  {
1820  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1821 
1822  static _GLIBCXX_CONSTEXPR long double
1823  min() _GLIBCXX_USE_NOEXCEPT { return __LDBL_MIN__; }
1824 
1825  static _GLIBCXX_CONSTEXPR long double
1826  max() _GLIBCXX_USE_NOEXCEPT { return __LDBL_MAX__; }
1827 
1828 #if __cplusplus >= 201103L
1829  static constexpr long double
1830  lowest() noexcept { return -__LDBL_MAX__; }
1831 #endif
1832 
1833  static _GLIBCXX_USE_CONSTEXPR int digits = __LDBL_MANT_DIG__;
1834  static _GLIBCXX_USE_CONSTEXPR int digits10 = __LDBL_DIG__;
1835 #if __cplusplus >= 201103L
1836  static _GLIBCXX_USE_CONSTEXPR int max_digits10
1837  = __glibcxx_max_digits10 (__LDBL_MANT_DIG__);
1838 #endif
1839  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1840  static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
1841  static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
1842  static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
1843 
1844  static _GLIBCXX_CONSTEXPR long double
1845  epsilon() _GLIBCXX_USE_NOEXCEPT { return __LDBL_EPSILON__; }
1846 
1847  static _GLIBCXX_CONSTEXPR long double
1848  round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5L; }
1849 
1850  static _GLIBCXX_USE_CONSTEXPR int min_exponent = __LDBL_MIN_EXP__;
1851  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __LDBL_MIN_10_EXP__;
1852  static _GLIBCXX_USE_CONSTEXPR int max_exponent = __LDBL_MAX_EXP__;
1853  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __LDBL_MAX_10_EXP__;
1854 
1855  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __LDBL_HAS_INFINITY__;
1856  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __LDBL_HAS_QUIET_NAN__;
1857  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN;
1858  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1859  = bool(__LDBL_HAS_DENORM__) ? denorm_present : denorm_absent;
1860  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
1861  = __glibcxx_long_double_has_denorm_loss;
1862 
1863  static _GLIBCXX_CONSTEXPR long double
1864  infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_vall(); }
1865 
1866  static _GLIBCXX_CONSTEXPR long double
1867  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nanl(""); }
1868 
1869  static _GLIBCXX_CONSTEXPR long double
1870  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nansl(""); }
1871 
1872  static _GLIBCXX_CONSTEXPR long double
1873  denorm_min() _GLIBCXX_USE_NOEXCEPT { return __LDBL_DENORM_MIN__; }
1874 
1875  static _GLIBCXX_USE_CONSTEXPR bool is_iec559
1877  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1878  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1879 
1880  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_long_double_traps;
1881  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before =
1882  __glibcxx_long_double_tinyness_before;
1883  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style =
1885  };
1886 
1887 #undef __glibcxx_long_double_has_denorm_loss
1888 #undef __glibcxx_long_double_traps
1889 #undef __glibcxx_long_double_tinyness_before
1890 
1891 _GLIBCXX_END_NAMESPACE_VERSION
1892 } // namespace
1893 
1894 #undef __glibcxx_signed
1895 #undef __glibcxx_min
1896 #undef __glibcxx_max
1897 #undef __glibcxx_digits
1898 #undef __glibcxx_digits10
1899 #undef __glibcxx_max_digits10
1900 
1901 #endif // _GLIBCXX_NUMERIC_LIMITS
ISO C++ entities toplevel namespace is std.
float_round_style
Describes the rounding style for floating-point types.
Definition: limits:168
@ round_toward_zero
Intermediate.
Definition: limits:170
@ round_toward_infinity
To the nearest representable value.
Definition: limits:172
@ round_to_nearest
To zero.
Definition: limits:171
@ round_toward_neg_infinity
To infinity.
Definition: limits:173
float_denorm_style
Describes the denormalization for floating-point types.
Definition: limits:183
@ denorm_present
The type allows denormalized values.
Definition: limits:189
@ denorm_indeterminate
Indeterminate at compile time whether denormalized values are allowed.
Definition: limits:185
@ denorm_absent
The type does not allow denormalized values.
Definition: limits:187
Part of std::numeric_limits.
Definition: limits:203
static constexpr bool is_modulo
Definition: limits:288
static constexpr bool has_quiet_NaN
Definition: limits:259
static constexpr bool is_integer
Definition: limits:226
static constexpr int max_digits10
Definition: limits:219
static constexpr int min_exponent
Definition: limits:239
static constexpr int digits
Definition: limits:211
static constexpr bool is_bounded
Definition: limits:279
static constexpr bool has_denorm_loss
Definition: limits:270
static constexpr bool is_iec559
Definition: limits:274
static constexpr bool is_exact
Definition: limits:231
static constexpr bool traps
Definition: limits:291
static constexpr bool has_signaling_NaN
Definition: limits:263
static constexpr bool is_specialized
Definition: limits:206
static constexpr int max_exponent
Definition: limits:248
static constexpr bool is_signed
Definition: limits:223
static constexpr int digits10
Definition: limits:214
static constexpr int min_exponent10
Definition: limits:243
static constexpr bool tinyness_before
Definition: limits:294
static constexpr float_round_style round_style
Definition: limits:299
static constexpr bool has_infinity
Definition: limits:255
static constexpr int radix
Definition: limits:235
static constexpr int max_exponent10
Definition: limits:252
static constexpr float_denorm_style has_denorm
Definition: limits:266
Properties of fundamental types.
Definition: limits:313
static constexpr _Tp max() noexcept
Definition: limits:321
static constexpr _Tp epsilon() noexcept
Definition: limits:333
static constexpr _Tp quiet_NaN() noexcept
Definition: limits:346
static constexpr _Tp lowest() noexcept
Definition: limits:327
static constexpr _Tp min() noexcept
Definition: limits:317
static constexpr _Tp denorm_min() noexcept
Definition: limits:357
static constexpr _Tp infinity() noexcept
Definition: limits:341
static constexpr _Tp round_error() noexcept
Definition: limits:337
static constexpr _Tp signaling_NaN() noexcept
Definition: limits:351
is_signed
Definition: type_traits:797