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-2017 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.
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 
378  // _GLIBCXX_RESOLVE_LIB_DEFECTS
379  // 184. numeric_limits<bool> wording problems
380 
381  /// numeric_limits<bool> specialization.
382  template<>
383  struct numeric_limits<bool>
384  {
385  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
386 
387  static _GLIBCXX_CONSTEXPR bool
388  min() _GLIBCXX_USE_NOEXCEPT { return false; }
389 
390  static _GLIBCXX_CONSTEXPR bool
391  max() _GLIBCXX_USE_NOEXCEPT { return true; }
392 
393 #if __cplusplus >= 201103L
394  static constexpr bool
395  lowest() noexcept { return min(); }
396 #endif
397  static _GLIBCXX_USE_CONSTEXPR int digits = 1;
398  static _GLIBCXX_USE_CONSTEXPR int digits10 = 0;
399 #if __cplusplus >= 201103L
400  static constexpr int max_digits10 = 0;
401 #endif
402  static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
403  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
404  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
405  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
406 
407  static _GLIBCXX_CONSTEXPR bool
408  epsilon() _GLIBCXX_USE_NOEXCEPT { return false; }
409 
410  static _GLIBCXX_CONSTEXPR bool
411  round_error() _GLIBCXX_USE_NOEXCEPT { return false; }
412 
413  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
414  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
415  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
416  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
417 
418  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
419  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
420  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
421  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
422  = denorm_absent;
423  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
424 
425  static _GLIBCXX_CONSTEXPR bool
426  infinity() _GLIBCXX_USE_NOEXCEPT { return false; }
427 
428  static _GLIBCXX_CONSTEXPR bool
429  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return false; }
430 
431  static _GLIBCXX_CONSTEXPR bool
432  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return false; }
433 
434  static _GLIBCXX_CONSTEXPR bool
435  denorm_min() _GLIBCXX_USE_NOEXCEPT { return false; }
436 
437  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
438  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
439  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
440 
441  // It is not clear what it means for a boolean type to trap.
442  // This is a DR on the LWG issue list. Here, I use integer
443  // promotion semantics.
444  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
445  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
446  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
448  };
449 
450  /// numeric_limits<char> specialization.
451  template<>
452  struct numeric_limits<char>
453  {
454  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
455 
456  static _GLIBCXX_CONSTEXPR char
457  min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min(char); }
458 
459  static _GLIBCXX_CONSTEXPR char
460  max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max(char); }
461 
462 #if __cplusplus >= 201103L
463  static constexpr char
464  lowest() noexcept { return min(); }
465 #endif
466 
467  static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (char);
468  static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (char);
469 #if __cplusplus >= 201103L
470  static constexpr int max_digits10 = 0;
471 #endif
472  static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (char);
473  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
474  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
475  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
476 
477  static _GLIBCXX_CONSTEXPR char
478  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
479 
480  static _GLIBCXX_CONSTEXPR char
481  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
482 
483  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
484  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
485  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
486  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
487 
488  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
489  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
490  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
491  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
492  = denorm_absent;
493  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
494 
495  static _GLIBCXX_CONSTEXPR
496  char infinity() _GLIBCXX_USE_NOEXCEPT { return char(); }
497 
498  static _GLIBCXX_CONSTEXPR char
499  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return char(); }
500 
501  static _GLIBCXX_CONSTEXPR char
502  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return char(); }
503 
504  static _GLIBCXX_CONSTEXPR char
505  denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<char>(0); }
506 
507  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
508  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
509  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = !is_signed;
510 
511  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
512  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
513  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
515  };
516 
517  /// numeric_limits<signed char> specialization.
518  template<>
519  struct numeric_limits<signed char>
520  {
521  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
522 
523  static _GLIBCXX_CONSTEXPR signed char
524  min() _GLIBCXX_USE_NOEXCEPT { return -__SCHAR_MAX__ - 1; }
525 
526  static _GLIBCXX_CONSTEXPR signed char
527  max() _GLIBCXX_USE_NOEXCEPT { return __SCHAR_MAX__; }
528 
529 #if __cplusplus >= 201103L
530  static constexpr signed char
531  lowest() noexcept { return min(); }
532 #endif
533 
534  static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (signed char);
535  static _GLIBCXX_USE_CONSTEXPR int digits10
536  = __glibcxx_digits10 (signed char);
537 #if __cplusplus >= 201103L
538  static constexpr int max_digits10 = 0;
539 #endif
540  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
541  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
542  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
543  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
544 
545  static _GLIBCXX_CONSTEXPR signed char
546  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
547 
548  static _GLIBCXX_CONSTEXPR signed char
549  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
550 
551  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
552  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
553  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
554  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
555 
556  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
557  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
558  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
559  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
560  = denorm_absent;
561  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
562 
563  static _GLIBCXX_CONSTEXPR signed char
564  infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<signed char>(0); }
565 
566  static _GLIBCXX_CONSTEXPR signed char
567  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<signed char>(0); }
568 
569  static _GLIBCXX_CONSTEXPR signed char
570  signaling_NaN() _GLIBCXX_USE_NOEXCEPT
571  { return static_cast<signed char>(0); }
572 
573  static _GLIBCXX_CONSTEXPR signed char
574  denorm_min() _GLIBCXX_USE_NOEXCEPT
575  { return static_cast<signed char>(0); }
576 
577  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
578  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
579  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
580 
581  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
582  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
583  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
585  };
586 
587  /// numeric_limits<unsigned char> specialization.
588  template<>
589  struct numeric_limits<unsigned char>
590  {
591  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
592 
593  static _GLIBCXX_CONSTEXPR unsigned char
594  min() _GLIBCXX_USE_NOEXCEPT { return 0; }
595 
596  static _GLIBCXX_CONSTEXPR unsigned char
597  max() _GLIBCXX_USE_NOEXCEPT { return __SCHAR_MAX__ * 2U + 1; }
598 
599 #if __cplusplus >= 201103L
600  static constexpr unsigned char
601  lowest() noexcept { return min(); }
602 #endif
603 
604  static _GLIBCXX_USE_CONSTEXPR int digits
605  = __glibcxx_digits (unsigned char);
606  static _GLIBCXX_USE_CONSTEXPR int digits10
607  = __glibcxx_digits10 (unsigned char);
608 #if __cplusplus >= 201103L
609  static constexpr int max_digits10 = 0;
610 #endif
611  static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
612  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
613  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
614  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
615 
616  static _GLIBCXX_CONSTEXPR unsigned char
617  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
618 
619  static _GLIBCXX_CONSTEXPR unsigned char
620  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
621 
622  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
623  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
624  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
625  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
626 
627  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
628  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
629  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
630  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
631  = denorm_absent;
632  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
633 
634  static _GLIBCXX_CONSTEXPR unsigned char
635  infinity() _GLIBCXX_USE_NOEXCEPT
636  { return static_cast<unsigned char>(0); }
637 
638  static _GLIBCXX_CONSTEXPR unsigned char
639  quiet_NaN() _GLIBCXX_USE_NOEXCEPT
640  { return static_cast<unsigned char>(0); }
641 
642  static _GLIBCXX_CONSTEXPR unsigned char
643  signaling_NaN() _GLIBCXX_USE_NOEXCEPT
644  { return static_cast<unsigned char>(0); }
645 
646  static _GLIBCXX_CONSTEXPR unsigned char
647  denorm_min() _GLIBCXX_USE_NOEXCEPT
648  { return static_cast<unsigned char>(0); }
649 
650  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
651  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
652  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
653 
654  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
655  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
656  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
658  };
659 
660  /// numeric_limits<wchar_t> specialization.
661  template<>
662  struct numeric_limits<wchar_t>
663  {
664  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
665 
666  static _GLIBCXX_CONSTEXPR wchar_t
667  min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min (wchar_t); }
668 
669  static _GLIBCXX_CONSTEXPR wchar_t
670  max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max (wchar_t); }
671 
672 #if __cplusplus >= 201103L
673  static constexpr wchar_t
674  lowest() noexcept { return min(); }
675 #endif
676 
677  static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (wchar_t);
678  static _GLIBCXX_USE_CONSTEXPR int digits10
679  = __glibcxx_digits10 (wchar_t);
680 #if __cplusplus >= 201103L
681  static constexpr int max_digits10 = 0;
682 #endif
683  static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (wchar_t);
684  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
685  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
686  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
687 
688  static _GLIBCXX_CONSTEXPR wchar_t
689  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
690 
691  static _GLIBCXX_CONSTEXPR wchar_t
692  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
693 
694  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
695  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
696  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
697  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
698 
699  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
700  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
701  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
702  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
703  = denorm_absent;
704  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
705 
706  static _GLIBCXX_CONSTEXPR wchar_t
707  infinity() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
708 
709  static _GLIBCXX_CONSTEXPR wchar_t
710  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
711 
712  static _GLIBCXX_CONSTEXPR wchar_t
713  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
714 
715  static _GLIBCXX_CONSTEXPR wchar_t
716  denorm_min() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
717 
718  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
719  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
720  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = !is_signed;
721 
722  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
723  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
724  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
726  };
727 
728 #if __cplusplus >= 201103L
729  /// numeric_limits<char16_t> specialization.
730  template<>
731  struct numeric_limits<char16_t>
732  {
733  static constexpr bool is_specialized = true;
734 
735  static constexpr char16_t
736  min() noexcept { return __glibcxx_min (char16_t); }
737 
738  static constexpr char16_t
739  max() noexcept { return __glibcxx_max (char16_t); }
740 
741  static constexpr char16_t
742  lowest() noexcept { return min(); }
743 
744  static constexpr int digits = __glibcxx_digits (char16_t);
745  static constexpr int digits10 = __glibcxx_digits10 (char16_t);
746  static constexpr int max_digits10 = 0;
747  static constexpr bool is_signed = __glibcxx_signed (char16_t);
748  static constexpr bool is_integer = true;
749  static constexpr bool is_exact = true;
750  static constexpr int radix = 2;
751 
752  static constexpr char16_t
753  epsilon() noexcept { return 0; }
754 
755  static constexpr char16_t
756  round_error() noexcept { return 0; }
757 
758  static constexpr int min_exponent = 0;
759  static constexpr int min_exponent10 = 0;
760  static constexpr int max_exponent = 0;
761  static constexpr int max_exponent10 = 0;
762 
763  static constexpr bool has_infinity = false;
764  static constexpr bool has_quiet_NaN = false;
765  static constexpr bool has_signaling_NaN = false;
766  static constexpr float_denorm_style has_denorm = denorm_absent;
767  static constexpr bool has_denorm_loss = false;
768 
769  static constexpr char16_t
770  infinity() noexcept { return char16_t(); }
771 
772  static constexpr char16_t
773  quiet_NaN() noexcept { return char16_t(); }
774 
775  static constexpr char16_t
776  signaling_NaN() noexcept { return char16_t(); }
777 
778  static constexpr char16_t
779  denorm_min() noexcept { return char16_t(); }
780 
781  static constexpr bool is_iec559 = false;
782  static constexpr bool is_bounded = true;
783  static constexpr bool is_modulo = !is_signed;
784 
785  static constexpr bool traps = __glibcxx_integral_traps;
786  static constexpr bool tinyness_before = false;
788  };
789 
790  /// numeric_limits<char32_t> specialization.
791  template<>
792  struct numeric_limits<char32_t>
793  {
794  static constexpr bool is_specialized = true;
795 
796  static constexpr char32_t
797  min() noexcept { return __glibcxx_min (char32_t); }
798 
799  static constexpr char32_t
800  max() noexcept { return __glibcxx_max (char32_t); }
801 
802  static constexpr char32_t
803  lowest() noexcept { return min(); }
804 
805  static constexpr int digits = __glibcxx_digits (char32_t);
806  static constexpr int digits10 = __glibcxx_digits10 (char32_t);
807  static constexpr int max_digits10 = 0;
808  static constexpr bool is_signed = __glibcxx_signed (char32_t);
809  static constexpr bool is_integer = true;
810  static constexpr bool is_exact = true;
811  static constexpr int radix = 2;
812 
813  static constexpr char32_t
814  epsilon() noexcept { return 0; }
815 
816  static constexpr char32_t
817  round_error() noexcept { return 0; }
818 
819  static constexpr int min_exponent = 0;
820  static constexpr int min_exponent10 = 0;
821  static constexpr int max_exponent = 0;
822  static constexpr int max_exponent10 = 0;
823 
824  static constexpr bool has_infinity = false;
825  static constexpr bool has_quiet_NaN = false;
826  static constexpr bool has_signaling_NaN = false;
827  static constexpr float_denorm_style has_denorm = denorm_absent;
828  static constexpr bool has_denorm_loss = false;
829 
830  static constexpr char32_t
831  infinity() noexcept { return char32_t(); }
832 
833  static constexpr char32_t
834  quiet_NaN() noexcept { return char32_t(); }
835 
836  static constexpr char32_t
837  signaling_NaN() noexcept { return char32_t(); }
838 
839  static constexpr char32_t
840  denorm_min() noexcept { return char32_t(); }
841 
842  static constexpr bool is_iec559 = false;
843  static constexpr bool is_bounded = true;
844  static constexpr bool is_modulo = !is_signed;
845 
846  static constexpr bool traps = __glibcxx_integral_traps;
847  static constexpr bool tinyness_before = false;
849  };
850 #endif
851 
852  /// numeric_limits<short> specialization.
853  template<>
854  struct numeric_limits<short>
855  {
856  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
857 
858  static _GLIBCXX_CONSTEXPR short
859  min() _GLIBCXX_USE_NOEXCEPT { return -__SHRT_MAX__ - 1; }
860 
861  static _GLIBCXX_CONSTEXPR short
862  max() _GLIBCXX_USE_NOEXCEPT { return __SHRT_MAX__; }
863 
864 #if __cplusplus >= 201103L
865  static constexpr short
866  lowest() noexcept { return min(); }
867 #endif
868 
869  static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (short);
870  static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (short);
871 #if __cplusplus >= 201103L
872  static constexpr int max_digits10 = 0;
873 #endif
874  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
875  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
876  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
877  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
878 
879  static _GLIBCXX_CONSTEXPR short
880  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
881 
882  static _GLIBCXX_CONSTEXPR short
883  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
884 
885  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
886  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
887  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
888  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
889 
890  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
891  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
892  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
893  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
894  = denorm_absent;
895  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
896 
897  static _GLIBCXX_CONSTEXPR short
898  infinity() _GLIBCXX_USE_NOEXCEPT { return short(); }
899 
900  static _GLIBCXX_CONSTEXPR short
901  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return short(); }
902 
903  static _GLIBCXX_CONSTEXPR short
904  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return short(); }
905 
906  static _GLIBCXX_CONSTEXPR short
907  denorm_min() _GLIBCXX_USE_NOEXCEPT { return short(); }
908 
909  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
910  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
911  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
912 
913  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
914  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
915  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
917  };
918 
919  /// numeric_limits<unsigned short> specialization.
920  template<>
921  struct numeric_limits<unsigned short>
922  {
923  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
924 
925  static _GLIBCXX_CONSTEXPR unsigned short
926  min() _GLIBCXX_USE_NOEXCEPT { return 0; }
927 
928  static _GLIBCXX_CONSTEXPR unsigned short
929  max() _GLIBCXX_USE_NOEXCEPT { return __SHRT_MAX__ * 2U + 1; }
930 
931 #if __cplusplus >= 201103L
932  static constexpr unsigned short
933  lowest() noexcept { return min(); }
934 #endif
935 
936  static _GLIBCXX_USE_CONSTEXPR int digits
937  = __glibcxx_digits (unsigned short);
938  static _GLIBCXX_USE_CONSTEXPR int digits10
939  = __glibcxx_digits10 (unsigned short);
940 #if __cplusplus >= 201103L
941  static constexpr int max_digits10 = 0;
942 #endif
943  static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
944  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
945  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
946  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
947 
948  static _GLIBCXX_CONSTEXPR unsigned short
949  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
950 
951  static _GLIBCXX_CONSTEXPR unsigned short
952  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
953 
954  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
955  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
956  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
957  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
958 
959  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
960  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
961  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
962  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
963  = denorm_absent;
964  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
965 
966  static _GLIBCXX_CONSTEXPR unsigned short
967  infinity() _GLIBCXX_USE_NOEXCEPT
968  { return static_cast<unsigned short>(0); }
969 
970  static _GLIBCXX_CONSTEXPR unsigned short
971  quiet_NaN() _GLIBCXX_USE_NOEXCEPT
972  { return static_cast<unsigned short>(0); }
973 
974  static _GLIBCXX_CONSTEXPR unsigned short
975  signaling_NaN() _GLIBCXX_USE_NOEXCEPT
976  { return static_cast<unsigned short>(0); }
977 
978  static _GLIBCXX_CONSTEXPR unsigned short
979  denorm_min() _GLIBCXX_USE_NOEXCEPT
980  { return static_cast<unsigned short>(0); }
981 
982  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
983  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
984  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
985 
986  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
987  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
988  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
990  };
991 
992  /// numeric_limits<int> specialization.
993  template<>
994  struct numeric_limits<int>
995  {
996  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
997 
998  static _GLIBCXX_CONSTEXPR int
999  min() _GLIBCXX_USE_NOEXCEPT { return -__INT_MAX__ - 1; }
1000 
1001  static _GLIBCXX_CONSTEXPR int
1002  max() _GLIBCXX_USE_NOEXCEPT { return __INT_MAX__; }
1003 
1004 #if __cplusplus >= 201103L
1005  static constexpr int
1006  lowest() noexcept { return min(); }
1007 #endif
1008 
1009  static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (int);
1010  static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (int);
1011 #if __cplusplus >= 201103L
1012  static constexpr int max_digits10 = 0;
1013 #endif
1014  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1015  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1016  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1017  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1018 
1019  static _GLIBCXX_CONSTEXPR int
1020  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1021 
1022  static _GLIBCXX_CONSTEXPR int
1023  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1024 
1025  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1026  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1027  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1028  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1029 
1030  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1031  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1032  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1033  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1034  = denorm_absent;
1035  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1036 
1037  static _GLIBCXX_CONSTEXPR int
1038  infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
1039 
1040  static _GLIBCXX_CONSTEXPR int
1041  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
1042 
1043  static _GLIBCXX_CONSTEXPR int
1044  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
1045 
1046  static _GLIBCXX_CONSTEXPR int
1047  denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
1048 
1049  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1050  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1051  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1052 
1053  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1054  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1055  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1057  };
1058 
1059  /// numeric_limits<unsigned int> specialization.
1060  template<>
1061  struct numeric_limits<unsigned int>
1062  {
1063  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1064 
1065  static _GLIBCXX_CONSTEXPR unsigned int
1066  min() _GLIBCXX_USE_NOEXCEPT { return 0; }
1067 
1068  static _GLIBCXX_CONSTEXPR unsigned int
1069  max() _GLIBCXX_USE_NOEXCEPT { return __INT_MAX__ * 2U + 1; }
1070 
1071 #if __cplusplus >= 201103L
1072  static constexpr unsigned int
1073  lowest() noexcept { return min(); }
1074 #endif
1075 
1076  static _GLIBCXX_USE_CONSTEXPR int digits
1077  = __glibcxx_digits (unsigned int);
1078  static _GLIBCXX_USE_CONSTEXPR int digits10
1079  = __glibcxx_digits10 (unsigned int);
1080 #if __cplusplus >= 201103L
1081  static constexpr int max_digits10 = 0;
1082 #endif
1083  static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
1084  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1085  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1086  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1087 
1088  static _GLIBCXX_CONSTEXPR unsigned int
1089  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1090 
1091  static _GLIBCXX_CONSTEXPR unsigned int
1092  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1093 
1094  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1095  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1096  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1097  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1098 
1099  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1100  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1101  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1102  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1103  = denorm_absent;
1104  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1105 
1106  static _GLIBCXX_CONSTEXPR unsigned int
1107  infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<unsigned int>(0); }
1108 
1109  static _GLIBCXX_CONSTEXPR unsigned int
1110  quiet_NaN() _GLIBCXX_USE_NOEXCEPT
1111  { return static_cast<unsigned int>(0); }
1112 
1113  static _GLIBCXX_CONSTEXPR unsigned int
1114  signaling_NaN() _GLIBCXX_USE_NOEXCEPT
1115  { return static_cast<unsigned int>(0); }
1116 
1117  static _GLIBCXX_CONSTEXPR unsigned int
1118  denorm_min() _GLIBCXX_USE_NOEXCEPT
1119  { return static_cast<unsigned int>(0); }
1120 
1121  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1122  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1123  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1124 
1125  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1126  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1127  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1129  };
1130 
1131  /// numeric_limits<long> specialization.
1132  template<>
1133  struct numeric_limits<long>
1134  {
1135  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1136 
1137  static _GLIBCXX_CONSTEXPR long
1138  min() _GLIBCXX_USE_NOEXCEPT { return -__LONG_MAX__ - 1; }
1139 
1140  static _GLIBCXX_CONSTEXPR long
1141  max() _GLIBCXX_USE_NOEXCEPT { return __LONG_MAX__; }
1142 
1143 #if __cplusplus >= 201103L
1144  static constexpr long
1145  lowest() noexcept { return min(); }
1146 #endif
1147 
1148  static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (long);
1149  static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (long);
1150 #if __cplusplus >= 201103L
1151  static constexpr int max_digits10 = 0;
1152 #endif
1153  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1154  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1155  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1156  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1157 
1158  static _GLIBCXX_CONSTEXPR long
1159  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1160 
1161  static _GLIBCXX_CONSTEXPR long
1162  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1163 
1164  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1165  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1166  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1167  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1168 
1169  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1170  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1171  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1172  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1173  = denorm_absent;
1174  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1175 
1176  static _GLIBCXX_CONSTEXPR long
1177  infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
1178 
1179  static _GLIBCXX_CONSTEXPR long
1180  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
1181 
1182  static _GLIBCXX_CONSTEXPR long
1183  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
1184 
1185  static _GLIBCXX_CONSTEXPR long
1186  denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
1187 
1188  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1189  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1190  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1191 
1192  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1193  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1194  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1196  };
1197 
1198  /// numeric_limits<unsigned long> specialization.
1199  template<>
1200  struct numeric_limits<unsigned long>
1201  {
1202  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1203 
1204  static _GLIBCXX_CONSTEXPR unsigned long
1205  min() _GLIBCXX_USE_NOEXCEPT { return 0; }
1206 
1207  static _GLIBCXX_CONSTEXPR unsigned long
1208  max() _GLIBCXX_USE_NOEXCEPT { return __LONG_MAX__ * 2UL + 1; }
1209 
1210 #if __cplusplus >= 201103L
1211  static constexpr unsigned long
1212  lowest() noexcept { return min(); }
1213 #endif
1214 
1215  static _GLIBCXX_USE_CONSTEXPR int digits
1216  = __glibcxx_digits (unsigned long);
1217  static _GLIBCXX_USE_CONSTEXPR int digits10
1218  = __glibcxx_digits10 (unsigned long);
1219 #if __cplusplus >= 201103L
1220  static constexpr int max_digits10 = 0;
1221 #endif
1222  static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
1223  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1224  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1225  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1226 
1227  static _GLIBCXX_CONSTEXPR unsigned long
1228  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1229 
1230  static _GLIBCXX_CONSTEXPR unsigned long
1231  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1232 
1233  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1234  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1235  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1236  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1237 
1238  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1239  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1240  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1241  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1242  = denorm_absent;
1243  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1244 
1245  static _GLIBCXX_CONSTEXPR unsigned long
1246  infinity() _GLIBCXX_USE_NOEXCEPT
1247  { return static_cast<unsigned long>(0); }
1248 
1249  static _GLIBCXX_CONSTEXPR unsigned long
1250  quiet_NaN() _GLIBCXX_USE_NOEXCEPT
1251  { return static_cast<unsigned long>(0); }
1252 
1253  static _GLIBCXX_CONSTEXPR unsigned long
1254  signaling_NaN() _GLIBCXX_USE_NOEXCEPT
1255  { return static_cast<unsigned long>(0); }
1256 
1257  static _GLIBCXX_CONSTEXPR unsigned long
1258  denorm_min() _GLIBCXX_USE_NOEXCEPT
1259  { return static_cast<unsigned long>(0); }
1260 
1261  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1262  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1263  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1264 
1265  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1266  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1267  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1269  };
1270 
1271  /// numeric_limits<long long> specialization.
1272  template<>
1273  struct numeric_limits<long long>
1274  {
1275  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1276 
1277  static _GLIBCXX_CONSTEXPR long long
1278  min() _GLIBCXX_USE_NOEXCEPT { return -__LONG_LONG_MAX__ - 1; }
1279 
1280  static _GLIBCXX_CONSTEXPR long long
1281  max() _GLIBCXX_USE_NOEXCEPT { return __LONG_LONG_MAX__; }
1282 
1283 #if __cplusplus >= 201103L
1284  static constexpr long long
1285  lowest() noexcept { return min(); }
1286 #endif
1287 
1288  static _GLIBCXX_USE_CONSTEXPR int digits
1289  = __glibcxx_digits (long long);
1290  static _GLIBCXX_USE_CONSTEXPR int digits10
1291  = __glibcxx_digits10 (long long);
1292 #if __cplusplus >= 201103L
1293  static constexpr int max_digits10 = 0;
1294 #endif
1295  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1296  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1297  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1298  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1299 
1300  static _GLIBCXX_CONSTEXPR long long
1301  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1302 
1303  static _GLIBCXX_CONSTEXPR long long
1304  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1305 
1306  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1307  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1308  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1309  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1310 
1311  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1312  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1313  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1314  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1315  = denorm_absent;
1316  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1317 
1318  static _GLIBCXX_CONSTEXPR long long
1319  infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); }
1320 
1321  static _GLIBCXX_CONSTEXPR long long
1322  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); }
1323 
1324  static _GLIBCXX_CONSTEXPR long long
1325  signaling_NaN() _GLIBCXX_USE_NOEXCEPT
1326  { return static_cast<long long>(0); }
1327 
1328  static _GLIBCXX_CONSTEXPR long long
1329  denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); }
1330 
1331  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1332  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1333  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1334 
1335  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1336  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1337  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1339  };
1340 
1341  /// numeric_limits<unsigned long long> specialization.
1342  template<>
1343  struct numeric_limits<unsigned long long>
1344  {
1345  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1346 
1347  static _GLIBCXX_CONSTEXPR unsigned long long
1348  min() _GLIBCXX_USE_NOEXCEPT { return 0; }
1349 
1350  static _GLIBCXX_CONSTEXPR unsigned long long
1351  max() _GLIBCXX_USE_NOEXCEPT { return __LONG_LONG_MAX__ * 2ULL + 1; }
1352 
1353 #if __cplusplus >= 201103L
1354  static constexpr unsigned long long
1355  lowest() noexcept { return min(); }
1356 #endif
1357 
1358  static _GLIBCXX_USE_CONSTEXPR int digits
1359  = __glibcxx_digits (unsigned long long);
1360  static _GLIBCXX_USE_CONSTEXPR int digits10
1361  = __glibcxx_digits10 (unsigned long long);
1362 #if __cplusplus >= 201103L
1363  static constexpr int max_digits10 = 0;
1364 #endif
1365  static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
1366  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1367  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1368  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1369 
1370  static _GLIBCXX_CONSTEXPR unsigned long long
1371  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1372 
1373  static _GLIBCXX_CONSTEXPR unsigned long long
1374  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1375 
1376  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1377  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1378  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1379  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1380 
1381  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1382  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1383  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1384  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1385  = denorm_absent;
1386  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1387 
1388  static _GLIBCXX_CONSTEXPR unsigned long long
1389  infinity() _GLIBCXX_USE_NOEXCEPT
1390  { return static_cast<unsigned long long>(0); }
1391 
1392  static _GLIBCXX_CONSTEXPR unsigned long long
1393  quiet_NaN() _GLIBCXX_USE_NOEXCEPT
1394  { return static_cast<unsigned long long>(0); }
1395 
1396  static _GLIBCXX_CONSTEXPR unsigned long long
1397  signaling_NaN() _GLIBCXX_USE_NOEXCEPT
1398  { return static_cast<unsigned long long>(0); }
1399 
1400  static _GLIBCXX_CONSTEXPR unsigned long long
1401  denorm_min() _GLIBCXX_USE_NOEXCEPT
1402  { return static_cast<unsigned long long>(0); }
1403 
1404  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1405  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1406  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1407 
1408  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1409  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1410  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1412  };
1413 
1414 #if !defined(__STRICT_ANSI__)
1415 
1416 #define __INT_N(TYPE, BITSIZE, EXT, UEXT) \
1417  template<> \
1418  struct numeric_limits<TYPE> \
1419  { \
1420  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; \
1421  \
1422  static _GLIBCXX_CONSTEXPR TYPE \
1423  min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min_b (TYPE, BITSIZE); } \
1424  \
1425  static _GLIBCXX_CONSTEXPR TYPE \
1426  max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max_b (TYPE, BITSIZE); } \
1427  \
1428  static _GLIBCXX_USE_CONSTEXPR int digits \
1429  = BITSIZE - 1; \
1430  static _GLIBCXX_USE_CONSTEXPR int digits10 \
1431  = (BITSIZE - 1) * 643L / 2136; \
1432  \
1433  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; \
1434  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; \
1435  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; \
1436  static _GLIBCXX_USE_CONSTEXPR int radix = 2; \
1437  \
1438  static _GLIBCXX_CONSTEXPR TYPE \
1439  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } \
1440  \
1441  static _GLIBCXX_CONSTEXPR TYPE \
1442  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } \
1443  \
1444  EXT \
1445  \
1446  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; \
1447  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; \
1448  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; \
1449  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; \
1450  \
1451  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; \
1452  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; \
1453  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; \
1454  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm \
1455  = denorm_absent; \
1456  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; \
1457  \
1458  static _GLIBCXX_CONSTEXPR TYPE \
1459  infinity() _GLIBCXX_USE_NOEXCEPT \
1460  { return static_cast<TYPE>(0); } \
1461  \
1462  static _GLIBCXX_CONSTEXPR TYPE \
1463  quiet_NaN() _GLIBCXX_USE_NOEXCEPT \
1464  { return static_cast<TYPE>(0); } \
1465  \
1466  static _GLIBCXX_CONSTEXPR TYPE \
1467  signaling_NaN() _GLIBCXX_USE_NOEXCEPT \
1468  { return static_cast<TYPE>(0); } \
1469  \
1470  static _GLIBCXX_CONSTEXPR TYPE \
1471  denorm_min() _GLIBCXX_USE_NOEXCEPT \
1472  { return static_cast<TYPE>(0); } \
1473  \
1474  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; \
1475  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; \
1476  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; \
1477  \
1478  static _GLIBCXX_USE_CONSTEXPR bool traps \
1479  = __glibcxx_integral_traps; \
1480  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; \
1481  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style \
1482  = round_toward_zero; \
1483  }; \
1484  \
1485  template<> \
1486  struct numeric_limits<unsigned TYPE> \
1487  { \
1488  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; \
1489  \
1490  static _GLIBCXX_CONSTEXPR unsigned TYPE \
1491  min() _GLIBCXX_USE_NOEXCEPT { return 0; } \
1492  \
1493  static _GLIBCXX_CONSTEXPR unsigned TYPE \
1494  max() _GLIBCXX_USE_NOEXCEPT \
1495  { return __glibcxx_max_b (unsigned TYPE, BITSIZE); } \
1496  \
1497  UEXT \
1498  \
1499  static _GLIBCXX_USE_CONSTEXPR int digits \
1500  = BITSIZE; \
1501  static _GLIBCXX_USE_CONSTEXPR int digits10 \
1502  = BITSIZE * 643L / 2136; \
1503  static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; \
1504  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; \
1505  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; \
1506  static _GLIBCXX_USE_CONSTEXPR int radix = 2; \
1507  \
1508  static _GLIBCXX_CONSTEXPR unsigned TYPE \
1509  epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } \
1510  \
1511  static _GLIBCXX_CONSTEXPR unsigned TYPE \
1512  round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } \
1513  \
1514  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; \
1515  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; \
1516  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; \
1517  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; \
1518  \
1519  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; \
1520  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; \
1521  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; \
1522  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm \
1523  = denorm_absent; \
1524  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; \
1525  \
1526  static _GLIBCXX_CONSTEXPR unsigned TYPE \
1527  infinity() _GLIBCXX_USE_NOEXCEPT \
1528  { return static_cast<unsigned TYPE>(0); } \
1529  \
1530  static _GLIBCXX_CONSTEXPR unsigned TYPE \
1531  quiet_NaN() _GLIBCXX_USE_NOEXCEPT \
1532  { return static_cast<unsigned TYPE>(0); } \
1533  \
1534  static _GLIBCXX_CONSTEXPR unsigned TYPE \
1535  signaling_NaN() _GLIBCXX_USE_NOEXCEPT \
1536  { return static_cast<unsigned TYPE>(0); } \
1537  \
1538  static _GLIBCXX_CONSTEXPR unsigned TYPE \
1539  denorm_min() _GLIBCXX_USE_NOEXCEPT \
1540  { return static_cast<unsigned TYPE>(0); } \
1541  \
1542  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; \
1543  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; \
1544  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; \
1545  \
1546  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; \
1547  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; \
1548  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style \
1549  = round_toward_zero; \
1550  };
1551 
1552 #if __cplusplus >= 201103L
1553 
1554 #define __INT_N_201103(TYPE) \
1555  static constexpr TYPE \
1556  lowest() noexcept { return min(); } \
1557  static constexpr int max_digits10 = 0;
1558 
1559 #define __INT_N_U201103(TYPE) \
1560  static constexpr unsigned TYPE \
1561  lowest() noexcept { return min(); } \
1562  static constexpr int max_digits10 = 0;
1563 
1564 #else
1565 #define __INT_N_201103(TYPE)
1566 #define __INT_N_U201103(TYPE)
1567 #endif
1568 
1569 #ifdef __GLIBCXX_TYPE_INT_N_0
1570  __INT_N(__GLIBCXX_TYPE_INT_N_0, __GLIBCXX_BITSIZE_INT_N_0,
1571  __INT_N_201103 (__GLIBCXX_TYPE_INT_N_0), __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_0))
1572 #endif
1573 #ifdef __GLIBCXX_TYPE_INT_N_1
1574  __INT_N (__GLIBCXX_TYPE_INT_N_1, __GLIBCXX_BITSIZE_INT_N_1,
1575  __INT_N_201103 (__GLIBCXX_TYPE_INT_N_1), __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_1))
1576 #endif
1577 #ifdef __GLIBCXX_TYPE_INT_N_2
1578  __INT_N (__GLIBCXX_TYPE_INT_N_2, __GLIBCXX_BITSIZE_INT_N_2,
1579  __INT_N_201103 (__GLIBCXX_TYPE_INT_N_2), __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_2))
1580 #endif
1581 #ifdef __GLIBCXX_TYPE_INT_N_3
1582  __INT_N (__GLIBCXX_TYPE_INT_N_3, __GLIBCXX_BITSIZE_INT_N_3,
1583  __INT_N_201103 (__GLIBCXX_TYPE_INT_N_3), __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_3))
1584 #endif
1585 
1586 #undef __INT_N
1587 #undef __INT_N_201103
1588 #undef __INT_N_U201103
1589 
1590 #endif
1591 
1592  /// numeric_limits<float> specialization.
1593  template<>
1594  struct numeric_limits<float>
1595  {
1596  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1597 
1598  static _GLIBCXX_CONSTEXPR float
1599  min() _GLIBCXX_USE_NOEXCEPT { return __FLT_MIN__; }
1600 
1601  static _GLIBCXX_CONSTEXPR float
1602  max() _GLIBCXX_USE_NOEXCEPT { return __FLT_MAX__; }
1603 
1604 #if __cplusplus >= 201103L
1605  static constexpr float
1606  lowest() noexcept { return -__FLT_MAX__; }
1607 #endif
1608 
1609  static _GLIBCXX_USE_CONSTEXPR int digits = __FLT_MANT_DIG__;
1610  static _GLIBCXX_USE_CONSTEXPR int digits10 = __FLT_DIG__;
1611 #if __cplusplus >= 201103L
1612  static constexpr int max_digits10
1613  = __glibcxx_max_digits10 (__FLT_MANT_DIG__);
1614 #endif
1615  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1616  static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
1617  static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
1618  static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
1619 
1620  static _GLIBCXX_CONSTEXPR float
1621  epsilon() _GLIBCXX_USE_NOEXCEPT { return __FLT_EPSILON__; }
1622 
1623  static _GLIBCXX_CONSTEXPR float
1624  round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5F; }
1625 
1626  static _GLIBCXX_USE_CONSTEXPR int min_exponent = __FLT_MIN_EXP__;
1627  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __FLT_MIN_10_EXP__;
1628  static _GLIBCXX_USE_CONSTEXPR int max_exponent = __FLT_MAX_EXP__;
1629  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __FLT_MAX_10_EXP__;
1630 
1631  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __FLT_HAS_INFINITY__;
1632  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __FLT_HAS_QUIET_NAN__;
1633  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN;
1634  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1635  = bool(__FLT_HAS_DENORM__) ? denorm_present : denorm_absent;
1636  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
1637  = __glibcxx_float_has_denorm_loss;
1638 
1639  static _GLIBCXX_CONSTEXPR float
1640  infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_valf(); }
1641 
1642  static _GLIBCXX_CONSTEXPR float
1643  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nanf(""); }
1644 
1645  static _GLIBCXX_CONSTEXPR float
1646  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nansf(""); }
1647 
1648  static _GLIBCXX_CONSTEXPR float
1649  denorm_min() _GLIBCXX_USE_NOEXCEPT { return __FLT_DENORM_MIN__; }
1650 
1651  static _GLIBCXX_USE_CONSTEXPR bool is_iec559
1652  = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
1653  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1654  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1655 
1656  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_float_traps;
1657  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before
1658  = __glibcxx_float_tinyness_before;
1659  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1660  = round_to_nearest;
1661  };
1662 
1663 #undef __glibcxx_float_has_denorm_loss
1664 #undef __glibcxx_float_traps
1665 #undef __glibcxx_float_tinyness_before
1666 
1667  /// numeric_limits<double> specialization.
1668  template<>
1669  struct numeric_limits<double>
1670  {
1671  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1672 
1673  static _GLIBCXX_CONSTEXPR double
1674  min() _GLIBCXX_USE_NOEXCEPT { return __DBL_MIN__; }
1675 
1676  static _GLIBCXX_CONSTEXPR double
1677  max() _GLIBCXX_USE_NOEXCEPT { return __DBL_MAX__; }
1678 
1679 #if __cplusplus >= 201103L
1680  static constexpr double
1681  lowest() noexcept { return -__DBL_MAX__; }
1682 #endif
1683 
1684  static _GLIBCXX_USE_CONSTEXPR int digits = __DBL_MANT_DIG__;
1685  static _GLIBCXX_USE_CONSTEXPR int digits10 = __DBL_DIG__;
1686 #if __cplusplus >= 201103L
1687  static constexpr int max_digits10
1688  = __glibcxx_max_digits10 (__DBL_MANT_DIG__);
1689 #endif
1690  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1691  static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
1692  static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
1693  static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
1694 
1695  static _GLIBCXX_CONSTEXPR double
1696  epsilon() _GLIBCXX_USE_NOEXCEPT { return __DBL_EPSILON__; }
1697 
1698  static _GLIBCXX_CONSTEXPR double
1699  round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5; }
1700 
1701  static _GLIBCXX_USE_CONSTEXPR int min_exponent = __DBL_MIN_EXP__;
1702  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __DBL_MIN_10_EXP__;
1703  static _GLIBCXX_USE_CONSTEXPR int max_exponent = __DBL_MAX_EXP__;
1704  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __DBL_MAX_10_EXP__;
1705 
1706  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __DBL_HAS_INFINITY__;
1707  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __DBL_HAS_QUIET_NAN__;
1708  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN;
1709  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1710  = bool(__DBL_HAS_DENORM__) ? denorm_present : denorm_absent;
1711  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
1712  = __glibcxx_double_has_denorm_loss;
1713 
1714  static _GLIBCXX_CONSTEXPR double
1715  infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_val(); }
1716 
1717  static _GLIBCXX_CONSTEXPR double
1718  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nan(""); }
1719 
1720  static _GLIBCXX_CONSTEXPR double
1721  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nans(""); }
1722 
1723  static _GLIBCXX_CONSTEXPR double
1724  denorm_min() _GLIBCXX_USE_NOEXCEPT { return __DBL_DENORM_MIN__; }
1725 
1726  static _GLIBCXX_USE_CONSTEXPR bool is_iec559
1727  = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
1728  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1729  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1730 
1731  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_double_traps;
1732  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before
1733  = __glibcxx_double_tinyness_before;
1734  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1735  = round_to_nearest;
1736  };
1737 
1738 #undef __glibcxx_double_has_denorm_loss
1739 #undef __glibcxx_double_traps
1740 #undef __glibcxx_double_tinyness_before
1741 
1742  /// numeric_limits<long double> specialization.
1743  template<>
1744  struct numeric_limits<long double>
1745  {
1746  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1747 
1748  static _GLIBCXX_CONSTEXPR long double
1749  min() _GLIBCXX_USE_NOEXCEPT { return __LDBL_MIN__; }
1750 
1751  static _GLIBCXX_CONSTEXPR long double
1752  max() _GLIBCXX_USE_NOEXCEPT { return __LDBL_MAX__; }
1753 
1754 #if __cplusplus >= 201103L
1755  static constexpr long double
1756  lowest() noexcept { return -__LDBL_MAX__; }
1757 #endif
1758 
1759  static _GLIBCXX_USE_CONSTEXPR int digits = __LDBL_MANT_DIG__;
1760  static _GLIBCXX_USE_CONSTEXPR int digits10 = __LDBL_DIG__;
1761 #if __cplusplus >= 201103L
1762  static _GLIBCXX_USE_CONSTEXPR int max_digits10
1763  = __glibcxx_max_digits10 (__LDBL_MANT_DIG__);
1764 #endif
1765  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1766  static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
1767  static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
1768  static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
1769 
1770  static _GLIBCXX_CONSTEXPR long double
1771  epsilon() _GLIBCXX_USE_NOEXCEPT { return __LDBL_EPSILON__; }
1772 
1773  static _GLIBCXX_CONSTEXPR long double
1774  round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5L; }
1775 
1776  static _GLIBCXX_USE_CONSTEXPR int min_exponent = __LDBL_MIN_EXP__;
1777  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __LDBL_MIN_10_EXP__;
1778  static _GLIBCXX_USE_CONSTEXPR int max_exponent = __LDBL_MAX_EXP__;
1779  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __LDBL_MAX_10_EXP__;
1780 
1781  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __LDBL_HAS_INFINITY__;
1782  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __LDBL_HAS_QUIET_NAN__;
1783  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN;
1784  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1785  = bool(__LDBL_HAS_DENORM__) ? denorm_present : denorm_absent;
1786  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
1787  = __glibcxx_long_double_has_denorm_loss;
1788 
1789  static _GLIBCXX_CONSTEXPR long double
1790  infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_vall(); }
1791 
1792  static _GLIBCXX_CONSTEXPR long double
1793  quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nanl(""); }
1794 
1795  static _GLIBCXX_CONSTEXPR long double
1796  signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nansl(""); }
1797 
1798  static _GLIBCXX_CONSTEXPR long double
1799  denorm_min() _GLIBCXX_USE_NOEXCEPT { return __LDBL_DENORM_MIN__; }
1800 
1801  static _GLIBCXX_USE_CONSTEXPR bool is_iec559
1802  = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
1803  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1804  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1805 
1806  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_long_double_traps;
1807  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before =
1808  __glibcxx_long_double_tinyness_before;
1809  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style =
1811  };
1812 
1813 #undef __glibcxx_long_double_has_denorm_loss
1814 #undef __glibcxx_long_double_traps
1815 #undef __glibcxx_long_double_tinyness_before
1816 
1817 _GLIBCXX_END_NAMESPACE_VERSION
1818 } // namespace
1819 
1820 #undef __glibcxx_signed
1821 #undef __glibcxx_min
1822 #undef __glibcxx_max
1823 #undef __glibcxx_digits
1824 #undef __glibcxx_digits10
1825 #undef __glibcxx_max_digits10
1826 
1827 #endif // _GLIBCXX_NUMERIC_LIMITS
static constexpr float_denorm_style has_denorm
Definition: limits:266
static constexpr _Tp denorm_min() noexcept
Definition: limits:357
Intermediate.
Definition: limits:170
static constexpr bool has_denorm_loss
Definition: limits:270
static constexpr bool has_quiet_NaN
Definition: limits:259
Properties of fundamental types.
Definition: limits:312
static constexpr _Tp quiet_NaN() noexcept
Definition: limits:346
static constexpr int min_exponent
Definition: limits:239
static constexpr int max_digits10
Definition: limits:219
ISO C++ entities toplevel namespace is std.
static constexpr bool tinyness_before
Definition: limits:294
static constexpr _Tp epsilon() noexcept
Definition: limits:333
static constexpr int digits10
Definition: limits:214
static constexpr int max_exponent10
Definition: limits:252
static constexpr bool is_bounded
Definition: limits:279
The type allows denormalized values.
Definition: limits:189
static constexpr bool is_specialized
Definition: limits:206
_GLIBCXX14_CONSTEXPR const _Tp & max(const _Tp &, const _Tp &)
This does what you think it does.
Definition: stl_algobase.h:219
static constexpr int digits
Definition: limits:211
static constexpr _Tp min() noexcept
Definition: limits:317
static constexpr _Tp infinity() noexcept
Definition: limits:341
static constexpr int radix
Definition: limits:235
static constexpr bool has_signaling_NaN
Definition: limits:263
static constexpr _Tp round_error() noexcept
Definition: limits:337
Indeterminate at compile time whether denormalized values are allowed.
Definition: limits:185
static constexpr float_round_style round_style
Definition: limits:299
static constexpr _Tp signaling_NaN() noexcept
Definition: limits:351
static constexpr bool has_infinity
Definition: limits:255
static constexpr int min_exponent10
Definition: limits:243
static constexpr bool is_signed
Definition: limits:223
static constexpr bool is_iec559
Definition: limits:274
static constexpr bool traps
Definition: limits:291
To the nearest representable value.
Definition: limits:172
static constexpr bool is_modulo
Definition: limits:288
float_denorm_style
Describes the denormalization for floating-point types.
Definition: limits:182
float_round_style
Describes the rounding style for floating-point types.
Definition: limits:167
Part of std::numeric_limits.
Definition: limits:202
The type does not allow denormalized values.
Definition: limits:187
static constexpr _Tp lowest() noexcept
Definition: limits:327
static constexpr int max_exponent
Definition: limits:248
static constexpr _Tp max() noexcept
Definition: limits:321
static constexpr bool is_integer
Definition: limits:226
_GLIBCXX14_CONSTEXPR const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
Definition: stl_algobase.h:195
static constexpr bool is_exact
Definition: limits:231
To zero.
Definition: limits:171