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