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, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
4 // 2008, 2009, 2010 Free Software Foundation, Inc.
5 //
6 // This file is part of the GNU ISO C++ Library. This library is free
7 // software; you can redistribute it and/or modify it under the
8 // terms of the GNU General Public License as published by the
9 // Free Software Foundation; either version 3, or (at your option)
10 // any later version.
11 
12 // This library is distributed in the hope that it will be useful,
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 // GNU General Public License for more details.
16 
17 // Under Section 7 of GPL version 3, you are granted additional
18 // permissions described in the GCC Runtime Library Exception, version
19 // 3.1, as published by the Free Software Foundation.
20 
21 // You should have received a copy of the GNU General Public License and
22 // a copy of the GCC Runtime Library Exception along with this program;
23 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
24 // <http://www.gnu.org/licenses/>.
25 
26 /** @file include/limits
27  * This is a Standard C++ Library header.
28  */
29 
30 // Note: this is not a conforming implementation.
31 // Written by Gabriel Dos Reis <[email protected]>
32 
33 //
34 // ISO 14882:1998
35 // 18.2.1
36 //
37 
38 #ifndef _GLIBCXX_NUMERIC_LIMITS
39 #define _GLIBCXX_NUMERIC_LIMITS 1
40 
41 #pragma GCC system_header
42 
43 #include <bits/c++config.h>
44 
45 //
46 // The numeric_limits<> traits document implementation-defined aspects
47 // of fundamental arithmetic data types (integers and floating points).
48 // From Standard C++ point of view, there are 14 such types:
49 // * integers
50 // bool (1)
51 // char, signed char, unsigned char, wchar_t (4)
52 // short, unsigned short (2)
53 // int, unsigned (2)
54 // long, unsigned long (2)
55 //
56 // * floating points
57 // float (1)
58 // double (1)
59 // long double (1)
60 //
61 // GNU C++ understands (where supported by the host C-library)
62 // * integer
63 // long long, unsigned long long (2)
64 //
65 // which brings us to 16 fundamental arithmetic data types in GNU C++.
66 //
67 //
68 // Since a numeric_limits<> is a bit tricky to get right, we rely on
69 // an interface composed of macros which should be defined in config/os
70 // or config/cpu when they differ from the generic (read arbitrary)
71 // definitions given here.
72 //
73 
74 // These values can be overridden in the target configuration file.
75 // The default values are appropriate for many 32-bit targets.
76 
77 // GCC only intrinsically supports modulo integral types. The only remaining
78 // integral exceptional values is division by zero. Only targets that do not
79 // signal division by zero in some "hard to ignore" way should use false.
80 #ifndef __glibcxx_integral_traps
81 # define __glibcxx_integral_traps true
82 #endif
83 
84 // float
85 //
86 
87 // Default values. Should be overridden in configuration files if necessary.
88 
89 #ifndef __glibcxx_float_has_denorm_loss
90 # define __glibcxx_float_has_denorm_loss false
91 #endif
92 #ifndef __glibcxx_float_traps
93 # define __glibcxx_float_traps false
94 #endif
95 #ifndef __glibcxx_float_tinyness_before
96 # define __glibcxx_float_tinyness_before false
97 #endif
98 
99 // double
100 
101 // Default values. Should be overridden in configuration files if necessary.
102 
103 #ifndef __glibcxx_double_has_denorm_loss
104 # define __glibcxx_double_has_denorm_loss false
105 #endif
106 #ifndef __glibcxx_double_traps
107 # define __glibcxx_double_traps false
108 #endif
109 #ifndef __glibcxx_double_tinyness_before
110 # define __glibcxx_double_tinyness_before false
111 #endif
112 
113 // long double
114 
115 // Default values. Should be overridden in configuration files if necessary.
116 
117 #ifndef __glibcxx_long_double_has_denorm_loss
118 # define __glibcxx_long_double_has_denorm_loss false
119 #endif
120 #ifndef __glibcxx_long_double_traps
121 # define __glibcxx_long_double_traps false
122 #endif
123 #ifndef __glibcxx_long_double_tinyness_before
124 # define __glibcxx_long_double_tinyness_before false
125 #endif
126 
127 // You should not need to define any macros below this point.
128 
129 #define __glibcxx_signed(T) ((T)(-1) < 0)
130 
131 #define __glibcxx_min(T) \
132  (__glibcxx_signed (T) ? (T)1 << __glibcxx_digits (T) : (T)0)
133 
134 #define __glibcxx_max(T) \
135  (__glibcxx_signed (T) ? \
136  (((((T)1 << (__glibcxx_digits (T) - 1)) - 1) << 1) + 1) : ~(T)0)
137 
138 #define __glibcxx_digits(T) \
139  (sizeof(T) * __CHAR_BIT__ - __glibcxx_signed (T))
140 
141 // The fraction 643/2136 approximates log10(2) to 7 significant digits.
142 #define __glibcxx_digits10(T) \
143  (__glibcxx_digits (T) * 643L / 2136)
144 
145 #define __glibcxx_max_digits10(T) \
146  (2 + (T) * 643L / 2136)
147 
148 namespace std _GLIBCXX_VISIBILITY(default)
149 {
150 _GLIBCXX_BEGIN_NAMESPACE_VERSION
151 
152  /**
153  * @brief Describes the rounding style for floating-point types.
154  *
155  * This is used in the std::numeric_limits class.
156  */
157  enum float_round_style
158  {
159  round_indeterminate = -1, /// Intermediate.
160  round_toward_zero = 0, /// To zero.
161  round_to_nearest = 1, /// To the nearest representable value.
162  round_toward_infinity = 2, /// To infinity.
163  round_toward_neg_infinity = 3 /// To negative infinity.
164  };
165 
166  /**
167  * @brief Describes the denormalization for floating-point types.
168  *
169  * These values represent the presence or absence of a variable number
170  * of exponent bits. This type is used in the std::numeric_limits class.
171  */
172  enum float_denorm_style
173  {
174  /// Indeterminate at compile time whether denormalized values are allowed.
175  denorm_indeterminate = -1,
176  /// The type does not allow denormalized values.
177  denorm_absent = 0,
178  /// The type allows denormalized values.
179  denorm_present = 1
180  };
181 
182  /**
183  * @brief Part of std::numeric_limits.
184  *
185  * The @c static @c const members are usable as integral constant
186  * expressions.
187  *
188  * @note This is a separate class for purposes of efficiency; you
189  * should only access these members as part of an instantiation
190  * of the std::numeric_limits class.
191  */
192  struct __numeric_limits_base
193  {
194  /** This will be true for all fundamental types (which have
195  specializations), and false for everything else. */
196  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = false;
197 
198  /** The number of @c radix digits that be represented without change: for
199  integer types, the number of non-sign bits in the mantissa; for
200  floating types, the number of @c radix digits in the mantissa. */
201  static _GLIBCXX_USE_CONSTEXPR int digits = 0;
202 
203  /** The number of base 10 digits that can be represented without change. */
204  static _GLIBCXX_USE_CONSTEXPR int digits10 = 0;
205 
206 #ifdef __GXX_EXPERIMENTAL_CXX0X__
207  /** The number of base 10 digits required to ensure that values which
208  differ are always differentiated. */
209  static constexpr int max_digits10 = 0;
210 #endif
211 
212  /** True if the type is signed. */
213  static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
214 
215  /** True if the type is integer.
216  * Is this supposed to be <em>if the type is integral?</em> */
217  static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
218 
219  /** True if the type uses an exact representation. <em>All integer types are
220  exact, but not all exact types are integer. For example, rational and
221  fixed-exponent representations are exact but not integer.</em>
222  [18.2.1.2]/15 */
223  static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
224 
225  /** For integer types, specifies the base of the representation. For
226  floating types, specifies the base of the exponent representation. */
227  static _GLIBCXX_USE_CONSTEXPR int radix = 0;
228 
229  /** The minimum negative integer such that @c radix raised to the power of
230  (one less than that integer) is a normalized floating point number. */
231  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
232 
233  /** The minimum negative integer such that 10 raised to that power is in
234  the range of normalized floating point numbers. */
235  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
236 
237  /** The maximum positive integer such that @c radix raised to the power of
238  (one less than that integer) is a representable finite floating point
239  number. */
240  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
241 
242  /** The maximum positive integer such that 10 raised to that power is in
243  the range of representable finite floating point numbers. */
244  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
245 
246  /** True if the type has a representation for positive infinity. */
247  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
248 
249  /** True if the type has a representation for a quiet (non-signaling)
250  <em>Not a Number</em>. */
251  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
252 
253  /** True if the type has a representation for a signaling
254  <em>Not a Number</em>. */
255  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
256 
257  /** See std::float_denorm_style for more information. */
258  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent;
259 
260  /** <em>True if loss of accuracy is detected as a denormalization loss,
261  rather than as an inexact result.</em> [18.2.1.2]/42 */
262  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
263 
264  /** True if-and-only-if the type adheres to the IEC 559 standard, also
265  known as IEEE 754. (Only makes sense for floating point types.) */
266  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
267 
268  /** <em>True if the set of values representable by the type is
269  finite. All built-in types are bounded, this member would be
270  false for arbitrary precision types.</em> [18.2.1.2]/54 */
271  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = false;
272 
273  /** True if the type is @e modulo, that is, if it is possible to add two
274  positive numbers and have a result that wraps around to a third number
275  that is less. Typically false for floating types, true for unsigned
276  integers, and true for 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() throw() { return static_cast<_Tp>(0); }
310 
311  /** The maximum finite value. */
312  static _GLIBCXX_CONSTEXPR _Tp
313  max() throw() { return static_cast<_Tp>(0); }
314 
315 #ifdef __GXX_EXPERIMENTAL_CXX0X__
316  /** A finite value x such that there is no other finite value y
317  * where y < x. */
318  static constexpr _Tp
319  lowest() throw() { return static_cast<_Tp>(0); }
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() throw() { return static_cast<_Tp>(0); }
326 
327  /** The maximum rounding error measurement (see LIA-1). */
328  static _GLIBCXX_CONSTEXPR _Tp
329  round_error() throw() { return static_cast<_Tp>(0); }
330 
331  /** The representation of positive infinity, if @c has_infinity. */
332  static _GLIBCXX_CONSTEXPR _Tp
333  infinity() throw() { return static_cast<_Tp>(0); }
334 
335  /** The representation of a quiet <em>Not a Number</em>,
336  if @c has_quiet_NaN. */
337  static _GLIBCXX_CONSTEXPR _Tp
338  quiet_NaN() throw() { return static_cast<_Tp>(0); }
339 
340  /** The representation of a signaling <em>Not a Number</em>, if
341  @c has_signaling_NaN. */
342  static _GLIBCXX_CONSTEXPR _Tp
343  signaling_NaN() throw() { return static_cast<_Tp>(0); }
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() throw() { return static_cast<_Tp>(0); }
350  };
351 
352 #ifdef __GXX_EXPERIMENTAL_CXX0X__
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() throw() { return false; }
377 
378  static _GLIBCXX_CONSTEXPR bool
379  max() throw() { return true; }
380 
381 #ifdef __GXX_EXPERIMENTAL_CXX0X__
382  static constexpr bool
383  lowest() throw() { return min(); }
384 #endif
385  static _GLIBCXX_USE_CONSTEXPR int digits = 1;
386  static _GLIBCXX_USE_CONSTEXPR int digits10 = 0;
387 #ifdef __GXX_EXPERIMENTAL_CXX0X__
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() throw() { return false; }
397 
398  static _GLIBCXX_CONSTEXPR bool
399  round_error() throw() { 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() throw() { return false; }
415 
416  static _GLIBCXX_CONSTEXPR bool
417  quiet_NaN() throw() { return false; }
418 
419  static _GLIBCXX_CONSTEXPR bool
420  signaling_NaN() throw() { return false; }
421 
422  static _GLIBCXX_CONSTEXPR bool
423  denorm_min() throw() { 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() throw() { return __glibcxx_min(char); }
446 
447  static _GLIBCXX_CONSTEXPR char
448  max() throw() { return __glibcxx_max(char); }
449 
450 #ifdef __GXX_EXPERIMENTAL_CXX0X__
451  static constexpr char
452  lowest() throw() { 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 #ifdef __GXX_EXPERIMENTAL_CXX0X__
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() throw() { return 0; }
467 
468  static _GLIBCXX_CONSTEXPR char
469  round_error() throw() { 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() throw() { return char(); }
485 
486  static _GLIBCXX_CONSTEXPR char
487  quiet_NaN() throw() { return char(); }
488 
489  static _GLIBCXX_CONSTEXPR char
490  signaling_NaN() throw() { return char(); }
491 
492  static _GLIBCXX_CONSTEXPR char
493  denorm_min() throw() { 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 = true;
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() throw() { return -__SCHAR_MAX__ - 1; }
513 
514  static _GLIBCXX_CONSTEXPR signed char
515  max() throw() { return __SCHAR_MAX__; }
516 
517 #ifdef __GXX_EXPERIMENTAL_CXX0X__
518  static constexpr signed char
519  lowest() throw() { 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 #ifdef __GXX_EXPERIMENTAL_CXX0X__
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() throw() { return 0; }
535 
536  static _GLIBCXX_CONSTEXPR signed char
537  round_error() throw() { 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() throw() { return static_cast<signed char>(0); }
553 
554  static _GLIBCXX_CONSTEXPR signed char
555  quiet_NaN() throw() { return static_cast<signed char>(0); }
556 
557  static _GLIBCXX_CONSTEXPR signed char
558  signaling_NaN() throw() { return static_cast<signed char>(0); }
559 
560  static _GLIBCXX_CONSTEXPR signed char
561  denorm_min() throw() { return static_cast<signed char>(0); }
562 
563  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
564  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
565  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
566 
567  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
568  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
569  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
570  = round_toward_zero;
571  };
572 
573  /// numeric_limits<unsigned char> specialization.
574  template<>
575  struct numeric_limits<unsigned char>
576  {
577  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
578 
579  static _GLIBCXX_CONSTEXPR unsigned char
580  min() throw() { return 0; }
581 
582  static _GLIBCXX_CONSTEXPR unsigned char
583  max() throw() { return __SCHAR_MAX__ * 2U + 1; }
584 
585 #ifdef __GXX_EXPERIMENTAL_CXX0X__
586  static constexpr unsigned char
587  lowest() throw() { return min(); }
588 #endif
589 
590  static _GLIBCXX_USE_CONSTEXPR int digits
591  = __glibcxx_digits (unsigned char);
592  static _GLIBCXX_USE_CONSTEXPR int digits10
593  = __glibcxx_digits10 (unsigned char);
594 #ifdef __GXX_EXPERIMENTAL_CXX0X__
595  static constexpr int max_digits10 = 0;
596 #endif
597  static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
598  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
599  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
600  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
601 
602  static _GLIBCXX_CONSTEXPR unsigned char
603  epsilon() throw() { return 0; }
604 
605  static _GLIBCXX_CONSTEXPR unsigned char
606  round_error() throw() { return 0; }
607 
608  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
609  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
610  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
611  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
612 
613  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
614  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
615  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
616  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
617  = denorm_absent;
618  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
619 
620  static _GLIBCXX_CONSTEXPR unsigned char
621  infinity() throw() { return static_cast<unsigned char>(0); }
622 
623  static _GLIBCXX_CONSTEXPR unsigned char
624  quiet_NaN() throw() { return static_cast<unsigned char>(0); }
625 
626  static _GLIBCXX_CONSTEXPR unsigned char
627  signaling_NaN() throw() { return static_cast<unsigned char>(0); }
628 
629  static _GLIBCXX_CONSTEXPR unsigned char
630  denorm_min() throw() { return static_cast<unsigned char>(0); }
631 
632  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
633  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
634  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
635 
636  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
637  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
638  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
639  = round_toward_zero;
640  };
641 
642  /// numeric_limits<wchar_t> specialization.
643  template<>
644  struct numeric_limits<wchar_t>
645  {
646  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
647 
648  static _GLIBCXX_CONSTEXPR wchar_t
649  min() throw() { return __glibcxx_min (wchar_t); }
650 
651  static _GLIBCXX_CONSTEXPR wchar_t
652  max() throw() { return __glibcxx_max (wchar_t); }
653 
654 #ifdef __GXX_EXPERIMENTAL_CXX0X__
655  static constexpr wchar_t
656  lowest() throw() { return min(); }
657 #endif
658 
659  static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (wchar_t);
660  static _GLIBCXX_USE_CONSTEXPR int digits10
661  = __glibcxx_digits10 (wchar_t);
662 #ifdef __GXX_EXPERIMENTAL_CXX0X__
663  static constexpr int max_digits10 = 0;
664 #endif
665  static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (wchar_t);
666  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
667  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
668  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
669 
670  static _GLIBCXX_CONSTEXPR wchar_t
671  epsilon() throw() { return 0; }
672 
673  static _GLIBCXX_CONSTEXPR wchar_t
674  round_error() throw() { return 0; }
675 
676  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
677  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
678  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
679  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
680 
681  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
682  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
683  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
684  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
685  = denorm_absent;
686  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
687 
688  static _GLIBCXX_CONSTEXPR wchar_t
689  infinity() throw() { return wchar_t(); }
690 
691  static _GLIBCXX_CONSTEXPR wchar_t
692  quiet_NaN() throw() { return wchar_t(); }
693 
694  static _GLIBCXX_CONSTEXPR wchar_t
695  signaling_NaN() throw() { return wchar_t(); }
696 
697  static _GLIBCXX_CONSTEXPR wchar_t
698  denorm_min() throw() { return wchar_t(); }
699 
700  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
701  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
702  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
703 
704  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
705  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
706  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
707  = round_toward_zero;
708  };
709 
710 #ifdef __GXX_EXPERIMENTAL_CXX0X__
711  /// numeric_limits<char16_t> specialization.
712  template<>
713  struct numeric_limits<char16_t>
714  {
715  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
716 
717  static _GLIBCXX_CONSTEXPR char16_t
718  min() throw() { return __glibcxx_min (char16_t); }
719 
720  static _GLIBCXX_CONSTEXPR char16_t
721  max() throw() { return __glibcxx_max (char16_t); }
722 
723 #ifdef __GXX_EXPERIMENTAL_CXX0X__
724  static constexpr char16_t
725  lowest() throw() { return min(); }
726 #endif
727 
728  static _GLIBCXX_USE_CONSTEXPR int digits
729  = __glibcxx_digits (char16_t);
730  static _GLIBCXX_USE_CONSTEXPR int digits10
731  = __glibcxx_digits10 (char16_t);
732 #ifdef __GXX_EXPERIMENTAL_CXX0X__
733  static constexpr int max_digits10 = 0;
734 #endif
735  static _GLIBCXX_USE_CONSTEXPR bool is_signed
736  = __glibcxx_signed (char16_t);
737  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
738  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
739  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
740 
741  static _GLIBCXX_CONSTEXPR char16_t
742  epsilon() throw() { return 0; }
743 
744  static _GLIBCXX_CONSTEXPR char16_t
745  round_error() throw() { return 0; }
746 
747  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
748  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
749  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
750  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
751 
752  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
753  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
754  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
755  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
756  = denorm_absent;
757  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
758 
759  static _GLIBCXX_CONSTEXPR char16_t
760  infinity() throw() { return char16_t(); }
761 
762  static _GLIBCXX_CONSTEXPR char16_t
763  quiet_NaN() throw() { return char16_t(); }
764 
765  static _GLIBCXX_CONSTEXPR char16_t
766  signaling_NaN() throw() { return char16_t(); }
767 
768  static _GLIBCXX_CONSTEXPR char16_t
769  denorm_min() throw() { return char16_t(); }
770 
771  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
772  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
773  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
774 
775  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
776  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
777  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
778  = round_toward_zero;
779  };
780 
781  /// numeric_limits<char32_t> specialization.
782  template<>
783  struct numeric_limits<char32_t>
784  {
785  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
786 
787  static _GLIBCXX_CONSTEXPR char32_t
788  min() throw() { return __glibcxx_min (char32_t); }
789 
790  static _GLIBCXX_CONSTEXPR char32_t
791  max() throw() { return __glibcxx_max (char32_t); }
792 
793 #ifdef __GXX_EXPERIMENTAL_CXX0X__
794  static constexpr char32_t
795  lowest() throw() { return min(); }
796 #endif
797 
798  static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (char32_t);
799  static _GLIBCXX_USE_CONSTEXPR int digits10
800  = __glibcxx_digits10 (char32_t);
801 #ifdef __GXX_EXPERIMENTAL_CXX0X__
802  static constexpr int max_digits10 = 0;
803 #endif
804  static _GLIBCXX_USE_CONSTEXPR bool is_signed
805  = __glibcxx_signed (char32_t);
806  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
807  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
808  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
809 
810  static _GLIBCXX_CONSTEXPR char32_t
811  epsilon() throw() { return 0; }
812 
813  static _GLIBCXX_CONSTEXPR char32_t
814  round_error() throw() { return 0; }
815 
816  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
817  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
818  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
819  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
820 
821  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
822  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
823  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
824  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
825  = denorm_absent;
826  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
827 
828  static _GLIBCXX_CONSTEXPR char32_t
829  infinity() throw() { return char32_t(); }
830 
831  static _GLIBCXX_CONSTEXPR char32_t
832  quiet_NaN() throw() { return char32_t(); }
833 
834  static _GLIBCXX_CONSTEXPR char32_t
835  signaling_NaN() throw() { return char32_t(); }
836 
837  static _GLIBCXX_CONSTEXPR char32_t
838  denorm_min() throw() { return char32_t(); }
839 
840  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
841  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
842  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
843 
844  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
845  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
846  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
847  = round_toward_zero;
848  };
849 #endif
850 
851  /// numeric_limits<short> specialization.
852  template<>
853  struct numeric_limits<short>
854  {
855  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
856 
857  static _GLIBCXX_CONSTEXPR short
858  min() throw() { return -__SHRT_MAX__ - 1; }
859 
860  static _GLIBCXX_CONSTEXPR short
861  max() throw() { return __SHRT_MAX__; }
862 
863 #ifdef __GXX_EXPERIMENTAL_CXX0X__
864  static constexpr short
865  lowest() throw() { return min(); }
866 #endif
867 
868  static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (short);
869  static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (short);
870 #ifdef __GXX_EXPERIMENTAL_CXX0X__
871  static constexpr int max_digits10 = 0;
872 #endif
873  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
874  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
875  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
876  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
877 
878  static _GLIBCXX_CONSTEXPR short
879  epsilon() throw() { return 0; }
880 
881  static _GLIBCXX_CONSTEXPR short
882  round_error() throw() { return 0; }
883 
884  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
885  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
886  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
887  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
888 
889  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
890  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
891  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
892  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
893  = denorm_absent;
894  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
895 
896  static _GLIBCXX_CONSTEXPR short
897  infinity() throw() { return short(); }
898 
899  static _GLIBCXX_CONSTEXPR short
900  quiet_NaN() throw() { return short(); }
901 
902  static _GLIBCXX_CONSTEXPR short
903  signaling_NaN() throw() { return short(); }
904 
905  static _GLIBCXX_CONSTEXPR short
906  denorm_min() throw() { return short(); }
907 
908  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
909  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
910  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
911 
912  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
913  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
914  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
915  = round_toward_zero;
916  };
917 
918  /// numeric_limits<unsigned short> specialization.
919  template<>
920  struct numeric_limits<unsigned short>
921  {
922  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
923 
924  static _GLIBCXX_CONSTEXPR unsigned short
925  min() throw() { return 0; }
926 
927  static _GLIBCXX_CONSTEXPR unsigned short
928  max() throw() { return __SHRT_MAX__ * 2U + 1; }
929 
930 #ifdef __GXX_EXPERIMENTAL_CXX0X__
931  static constexpr unsigned short
932  lowest() throw() { return min(); }
933 #endif
934 
935  static _GLIBCXX_USE_CONSTEXPR int digits
936  = __glibcxx_digits (unsigned short);
937  static _GLIBCXX_USE_CONSTEXPR int digits10
938  = __glibcxx_digits10 (unsigned short);
939 #ifdef __GXX_EXPERIMENTAL_CXX0X__
940  static constexpr int max_digits10 = 0;
941 #endif
942  static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
943  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
944  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
945  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
946 
947  static _GLIBCXX_CONSTEXPR unsigned short
948  epsilon() throw() { return 0; }
949 
950  static _GLIBCXX_CONSTEXPR unsigned short
951  round_error() throw() { return 0; }
952 
953  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
954  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
955  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
956  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
957 
958  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
959  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
960  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
961  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
962  = denorm_absent;
963  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
964 
965  static _GLIBCXX_CONSTEXPR unsigned short
966  infinity() throw() { return static_cast<unsigned short>(0); }
967 
968  static _GLIBCXX_CONSTEXPR unsigned short
969  quiet_NaN() throw() { return static_cast<unsigned short>(0); }
970 
971  static _GLIBCXX_CONSTEXPR unsigned short
972  signaling_NaN() throw() { return static_cast<unsigned short>(0); }
973 
974  static _GLIBCXX_CONSTEXPR unsigned short
975  denorm_min() throw() { return static_cast<unsigned short>(0); }
976 
977  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
978  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
979  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
980 
981  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
982  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
983  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
984  = round_toward_zero;
985  };
986 
987  /// numeric_limits<int> specialization.
988  template<>
989  struct numeric_limits<int>
990  {
991  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
992 
993  static _GLIBCXX_CONSTEXPR int
994  min() throw() { return -__INT_MAX__ - 1; }
995 
996  static _GLIBCXX_CONSTEXPR int
997  max() throw() { return __INT_MAX__; }
998 
999 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1000  static constexpr int
1001  lowest() throw() { return min(); }
1002 #endif
1003 
1004  static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (int);
1005  static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (int);
1006 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1007  static constexpr int max_digits10 = 0;
1008 #endif
1009  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1010  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1011  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1012  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1013 
1014  static _GLIBCXX_CONSTEXPR int
1015  epsilon() throw() { return 0; }
1016 
1017  static _GLIBCXX_CONSTEXPR int
1018  round_error() throw() { return 0; }
1019 
1020  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1021  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1022  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1023  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1024 
1025  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1026  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1027  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1028  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1029  = denorm_absent;
1030  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1031 
1032  static _GLIBCXX_CONSTEXPR int
1033  infinity() throw() { return static_cast<int>(0); }
1034 
1035  static _GLIBCXX_CONSTEXPR int
1036  quiet_NaN() throw() { return static_cast<int>(0); }
1037 
1038  static _GLIBCXX_CONSTEXPR int
1039  signaling_NaN() throw() { return static_cast<int>(0); }
1040 
1041  static _GLIBCXX_CONSTEXPR int
1042  denorm_min() throw() { return static_cast<int>(0); }
1043 
1044  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1045  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1046  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1047 
1048  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1049  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1050  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1051  = round_toward_zero;
1052  };
1053 
1054  /// numeric_limits<unsigned int> specialization.
1055  template<>
1056  struct numeric_limits<unsigned int>
1057  {
1058  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1059 
1060  static _GLIBCXX_CONSTEXPR unsigned int
1061  min() throw() { return 0; }
1062 
1063  static _GLIBCXX_CONSTEXPR unsigned int
1064  max() throw() { return __INT_MAX__ * 2U + 1; }
1065 
1066 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1067  static constexpr unsigned int
1068  lowest() throw() { return min(); }
1069 #endif
1070 
1071  static _GLIBCXX_USE_CONSTEXPR int digits
1072  = __glibcxx_digits (unsigned int);
1073  static _GLIBCXX_USE_CONSTEXPR int digits10
1074  = __glibcxx_digits10 (unsigned int);
1075 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1076  static constexpr int max_digits10 = 0;
1077 #endif
1078  static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
1079  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1080  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1081  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1082 
1083  static _GLIBCXX_CONSTEXPR unsigned int
1084  epsilon() throw() { return 0; }
1085 
1086  static _GLIBCXX_CONSTEXPR unsigned int
1087  round_error() throw() { return 0; }
1088 
1089  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1090  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1091  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1092  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1093 
1094  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1095  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1096  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1097  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1098  = denorm_absent;
1099  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1100 
1101  static _GLIBCXX_CONSTEXPR unsigned int
1102  infinity() throw() { return static_cast<unsigned int>(0); }
1103 
1104  static _GLIBCXX_CONSTEXPR unsigned int
1105  quiet_NaN() throw() { return static_cast<unsigned int>(0); }
1106 
1107  static _GLIBCXX_CONSTEXPR unsigned int
1108  signaling_NaN() throw() { return static_cast<unsigned int>(0); }
1109 
1110  static _GLIBCXX_CONSTEXPR unsigned int
1111  denorm_min() throw() { return static_cast<unsigned int>(0); }
1112 
1113  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1114  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1115  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1116 
1117  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1118  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1119  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1120  = round_toward_zero;
1121  };
1122 
1123  /// numeric_limits<long> specialization.
1124  template<>
1125  struct numeric_limits<long>
1126  {
1127  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1128 
1129  static _GLIBCXX_CONSTEXPR long
1130  min() throw() { return -__LONG_MAX__ - 1; }
1131 
1132  static _GLIBCXX_CONSTEXPR long
1133  max() throw() { return __LONG_MAX__; }
1134 
1135 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1136  static constexpr long
1137  lowest() throw() { return min(); }
1138 #endif
1139 
1140  static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (long);
1141  static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (long);
1142 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1143  static constexpr int max_digits10 = 0;
1144 #endif
1145  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1146  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1147  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1148  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1149 
1150  static _GLIBCXX_CONSTEXPR long
1151  epsilon() throw() { return 0; }
1152 
1153  static _GLIBCXX_CONSTEXPR long
1154  round_error() throw() { return 0; }
1155 
1156  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1157  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1158  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1159  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1160 
1161  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1162  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1163  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1164  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1165  = denorm_absent;
1166  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1167 
1168  static _GLIBCXX_CONSTEXPR long
1169  infinity() throw() { return static_cast<long>(0); }
1170 
1171  static _GLIBCXX_CONSTEXPR long
1172  quiet_NaN() throw() { return static_cast<long>(0); }
1173 
1174  static _GLIBCXX_CONSTEXPR long
1175  signaling_NaN() throw() { return static_cast<long>(0); }
1176 
1177  static _GLIBCXX_CONSTEXPR long
1178  denorm_min() throw() { return static_cast<long>(0); }
1179 
1180  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1181  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1182  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1183 
1184  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1185  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1186  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1187  = round_toward_zero;
1188  };
1189 
1190  /// numeric_limits<unsigned long> specialization.
1191  template<>
1192  struct numeric_limits<unsigned long>
1193  {
1194  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1195 
1196  static _GLIBCXX_CONSTEXPR unsigned long
1197  min() throw() { return 0; }
1198 
1199  static _GLIBCXX_CONSTEXPR unsigned long
1200  max() throw() { return __LONG_MAX__ * 2UL + 1; }
1201 
1202 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1203  static constexpr unsigned long
1204  lowest() throw() { return min(); }
1205 #endif
1206 
1207  static _GLIBCXX_USE_CONSTEXPR int digits
1208  = __glibcxx_digits (unsigned long);
1209  static _GLIBCXX_USE_CONSTEXPR int digits10
1210  = __glibcxx_digits10 (unsigned long);
1211 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1212  static constexpr int max_digits10 = 0;
1213 #endif
1214  static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
1215  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1216  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1217  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1218 
1219  static _GLIBCXX_CONSTEXPR unsigned long
1220  epsilon() throw() { return 0; }
1221 
1222  static _GLIBCXX_CONSTEXPR unsigned long
1223  round_error() throw() { return 0; }
1224 
1225  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1226  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1227  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1228  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1229 
1230  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1231  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1232  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1233  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1234  = denorm_absent;
1235  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1236 
1237  static _GLIBCXX_CONSTEXPR unsigned long
1238  infinity() throw() { return static_cast<unsigned long>(0); }
1239 
1240  static _GLIBCXX_CONSTEXPR unsigned long
1241  quiet_NaN() throw() { return static_cast<unsigned long>(0); }
1242 
1243  static _GLIBCXX_CONSTEXPR unsigned long
1244  signaling_NaN() throw() { return static_cast<unsigned long>(0); }
1245 
1246  static _GLIBCXX_CONSTEXPR unsigned long
1247  denorm_min() throw() { 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() throw() { return -__LONG_LONG_MAX__ - 1; }
1267 
1268  static _GLIBCXX_CONSTEXPR long long
1269  max() throw() { return __LONG_LONG_MAX__; }
1270 
1271 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1272  static constexpr long long
1273  lowest() throw() { 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 #ifdef __GXX_EXPERIMENTAL_CXX0X__
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() throw() { return 0; }
1290 
1291  static _GLIBCXX_CONSTEXPR long long
1292  round_error() throw() { 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() throw() { return static_cast<long long>(0); }
1308 
1309  static _GLIBCXX_CONSTEXPR long long
1310  quiet_NaN() throw() { return static_cast<long long>(0); }
1311 
1312  static _GLIBCXX_CONSTEXPR long long
1313  signaling_NaN() throw() { return static_cast<long long>(0); }
1314 
1315  static _GLIBCXX_CONSTEXPR long long
1316  denorm_min() throw() { return static_cast<long long>(0); }
1317 
1318  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1319  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1320  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1321 
1322  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1323  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1324  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1325  = round_toward_zero;
1326  };
1327 
1328  /// numeric_limits<unsigned long long> specialization.
1329  template<>
1330  struct numeric_limits<unsigned long long>
1331  {
1332  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1333 
1334  static _GLIBCXX_CONSTEXPR unsigned long long
1335  min() throw() { return 0; }
1336 
1337  static _GLIBCXX_CONSTEXPR unsigned long long
1338  max() throw() { return __LONG_LONG_MAX__ * 2ULL + 1; }
1339 
1340 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1341  static constexpr unsigned long long
1342  lowest() throw() { return min(); }
1343 #endif
1344 
1345  static _GLIBCXX_USE_CONSTEXPR int digits
1346  = __glibcxx_digits (unsigned long long);
1347  static _GLIBCXX_USE_CONSTEXPR int digits10
1348  = __glibcxx_digits10 (unsigned long long);
1349 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1350  static constexpr int max_digits10 = 0;
1351 #endif
1352  static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
1353  static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1354  static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1355  static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1356 
1357  static _GLIBCXX_CONSTEXPR unsigned long long
1358  epsilon() throw() { return 0; }
1359 
1360  static _GLIBCXX_CONSTEXPR unsigned long long
1361  round_error() throw() { return 0; }
1362 
1363  static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1364  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1365  static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1366  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1367 
1368  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1369  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1370  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1371  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1372  = denorm_absent;
1373  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1374 
1375  static _GLIBCXX_CONSTEXPR unsigned long long
1376  infinity() throw() { return static_cast<unsigned long long>(0); }
1377 
1378  static _GLIBCXX_CONSTEXPR unsigned long long
1379  quiet_NaN() throw() { return static_cast<unsigned long long>(0); }
1380 
1381  static _GLIBCXX_CONSTEXPR unsigned long long
1382  signaling_NaN() throw() { return static_cast<unsigned long long>(0); }
1383 
1384  static _GLIBCXX_CONSTEXPR unsigned long long
1385  denorm_min() throw() { return static_cast<unsigned long long>(0); }
1386 
1387  static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1388  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1389  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1390 
1391  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1392  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1393  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1394  = round_toward_zero;
1395  };
1396 
1397  /// numeric_limits<float> specialization.
1398  template<>
1399  struct numeric_limits<float>
1400  {
1401  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1402 
1403  static _GLIBCXX_CONSTEXPR float
1404  min() throw() { return __FLT_MIN__; }
1405 
1406  static _GLIBCXX_CONSTEXPR float
1407  max() throw() { return __FLT_MAX__; }
1408 
1409 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1410  static constexpr float
1411  lowest() throw() { return -__FLT_MAX__; }
1412 #endif
1413 
1414  static _GLIBCXX_USE_CONSTEXPR int digits = __FLT_MANT_DIG__;
1415  static _GLIBCXX_USE_CONSTEXPR int digits10 = __FLT_DIG__;
1416 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1417  static constexpr int max_digits10
1418  = __glibcxx_max_digits10 (__FLT_MANT_DIG__);
1419 #endif
1420  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1421  static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
1422  static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
1423  static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
1424 
1425  static _GLIBCXX_CONSTEXPR float
1426  epsilon() throw() { return __FLT_EPSILON__; }
1427 
1428  static _GLIBCXX_CONSTEXPR float
1429  round_error() throw() { return 0.5F; }
1430 
1431  static _GLIBCXX_USE_CONSTEXPR int min_exponent = __FLT_MIN_EXP__;
1432  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __FLT_MIN_10_EXP__;
1433  static _GLIBCXX_USE_CONSTEXPR int max_exponent = __FLT_MAX_EXP__;
1434  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __FLT_MAX_10_EXP__;
1435 
1436  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __FLT_HAS_INFINITY__;
1437  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __FLT_HAS_QUIET_NAN__;
1438  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN;
1439  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1440  = bool(__FLT_HAS_DENORM__) ? denorm_present : denorm_absent;
1441  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
1442  = __glibcxx_float_has_denorm_loss;
1443 
1444  static _GLIBCXX_CONSTEXPR float
1445  infinity() throw() { return __builtin_huge_valf (); }
1446 
1447  static _GLIBCXX_CONSTEXPR float
1448  quiet_NaN() throw() { return __builtin_nanf (""); }
1449 
1450  static _GLIBCXX_CONSTEXPR float
1451  signaling_NaN() throw() { return __builtin_nansf (""); }
1452 
1453  static _GLIBCXX_CONSTEXPR float
1454  denorm_min() throw() { return __FLT_DENORM_MIN__; }
1455 
1456  static _GLIBCXX_USE_CONSTEXPR bool is_iec559
1457  = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
1458  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1459  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1460 
1461  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_float_traps;
1462  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before
1463  = __glibcxx_float_tinyness_before;
1464  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1465  = round_to_nearest;
1466  };
1467 
1468 #undef __glibcxx_float_has_denorm_loss
1469 #undef __glibcxx_float_traps
1470 #undef __glibcxx_float_tinyness_before
1471 
1472  /// numeric_limits<double> specialization.
1473  template<>
1474  struct numeric_limits<double>
1475  {
1476  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1477 
1478  static _GLIBCXX_CONSTEXPR double
1479  min() throw() { return __DBL_MIN__; }
1480 
1481  static _GLIBCXX_CONSTEXPR double
1482  max() throw() { return __DBL_MAX__; }
1483 
1484 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1485  static constexpr double
1486  lowest() throw() { return -__DBL_MAX__; }
1487 #endif
1488 
1489  static _GLIBCXX_USE_CONSTEXPR int digits = __DBL_MANT_DIG__;
1490  static _GLIBCXX_USE_CONSTEXPR int digits10 = __DBL_DIG__;
1491 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1492  static constexpr int max_digits10
1493  = __glibcxx_max_digits10 (__DBL_MANT_DIG__);
1494 #endif
1495  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1496  static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
1497  static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
1498  static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
1499 
1500  static _GLIBCXX_CONSTEXPR double
1501  epsilon() throw() { return __DBL_EPSILON__; }
1502 
1503  static _GLIBCXX_CONSTEXPR double
1504  round_error() throw() { return 0.5; }
1505 
1506  static _GLIBCXX_USE_CONSTEXPR int min_exponent = __DBL_MIN_EXP__;
1507  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __DBL_MIN_10_EXP__;
1508  static _GLIBCXX_USE_CONSTEXPR int max_exponent = __DBL_MAX_EXP__;
1509  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __DBL_MAX_10_EXP__;
1510 
1511  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __DBL_HAS_INFINITY__;
1512  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __DBL_HAS_QUIET_NAN__;
1513  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN;
1514  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1515  = bool(__DBL_HAS_DENORM__) ? denorm_present : denorm_absent;
1516  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
1517  = __glibcxx_double_has_denorm_loss;
1518 
1519  static _GLIBCXX_CONSTEXPR double
1520  infinity() throw() { return __builtin_huge_val(); }
1521 
1522  static _GLIBCXX_CONSTEXPR double
1523  quiet_NaN() throw() { return __builtin_nan (""); }
1524 
1525  static _GLIBCXX_CONSTEXPR double
1526  signaling_NaN() throw() { return __builtin_nans (""); }
1527 
1528  static _GLIBCXX_CONSTEXPR double
1529  denorm_min() throw() { return __DBL_DENORM_MIN__; }
1530 
1531  static _GLIBCXX_USE_CONSTEXPR bool is_iec559
1532  = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
1533  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1534  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1535 
1536  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_double_traps;
1537  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before
1538  = __glibcxx_double_tinyness_before;
1539  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1540  = round_to_nearest;
1541  };
1542 
1543 #undef __glibcxx_double_has_denorm_loss
1544 #undef __glibcxx_double_traps
1545 #undef __glibcxx_double_tinyness_before
1546 
1547  /// numeric_limits<long double> specialization.
1548  template<>
1549  struct numeric_limits<long double>
1550  {
1551  static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1552 
1553  static _GLIBCXX_CONSTEXPR long double
1554  min() throw() { return __LDBL_MIN__; }
1555 
1556  static _GLIBCXX_CONSTEXPR long double
1557  max() throw() { return __LDBL_MAX__; }
1558 
1559 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1560  static constexpr long double
1561  lowest() throw() { return -__LDBL_MAX__; }
1562 #endif
1563 
1564  static _GLIBCXX_USE_CONSTEXPR int digits = __LDBL_MANT_DIG__;
1565  static _GLIBCXX_USE_CONSTEXPR int digits10 = __LDBL_DIG__;
1566 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1567  static _GLIBCXX_USE_CONSTEXPR int max_digits10
1568  = __glibcxx_max_digits10 (__LDBL_MANT_DIG__);
1569 #endif
1570  static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1571  static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
1572  static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
1573  static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
1574 
1575  static _GLIBCXX_CONSTEXPR long double
1576  epsilon() throw() { return __LDBL_EPSILON__; }
1577 
1578  static _GLIBCXX_CONSTEXPR long double
1579  round_error() throw() { return 0.5L; }
1580 
1581  static _GLIBCXX_USE_CONSTEXPR int min_exponent = __LDBL_MIN_EXP__;
1582  static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __LDBL_MIN_10_EXP__;
1583  static _GLIBCXX_USE_CONSTEXPR int max_exponent = __LDBL_MAX_EXP__;
1584  static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __LDBL_MAX_10_EXP__;
1585 
1586  static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __LDBL_HAS_INFINITY__;
1587  static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __LDBL_HAS_QUIET_NAN__;
1588  static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN;
1589  static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1590  = bool(__LDBL_HAS_DENORM__) ? denorm_present : denorm_absent;
1591  static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
1592  = __glibcxx_long_double_has_denorm_loss;
1593 
1594  static _GLIBCXX_CONSTEXPR long double
1595  infinity() throw() { return __builtin_huge_vall (); }
1596 
1597  static _GLIBCXX_CONSTEXPR long double
1598  quiet_NaN() throw() { return __builtin_nanl (""); }
1599 
1600  static _GLIBCXX_CONSTEXPR long double
1601  signaling_NaN() throw() { return __builtin_nansl (""); }
1602 
1603  static _GLIBCXX_CONSTEXPR long double
1604  denorm_min() throw() { return __LDBL_DENORM_MIN__; }
1605 
1606  static _GLIBCXX_USE_CONSTEXPR bool is_iec559
1607  = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
1608  static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1609  static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1610 
1611  static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_long_double_traps;
1612  static _GLIBCXX_USE_CONSTEXPR bool tinyness_before =
1613  __glibcxx_long_double_tinyness_before;
1614  static _GLIBCXX_USE_CONSTEXPR float_round_style round_style =
1615  round_to_nearest;
1616  };
1617 
1618 #undef __glibcxx_long_double_has_denorm_loss
1619 #undef __glibcxx_long_double_traps
1620 #undef __glibcxx_long_double_tinyness_before
1621 
1622 _GLIBCXX_END_NAMESPACE_VERSION
1623 } // namespace
1624 
1625 #undef __glibcxx_signed
1626 #undef __glibcxx_min
1627 #undef __glibcxx_max
1628 #undef __glibcxx_digits
1629 #undef __glibcxx_digits10
1630 #undef __glibcxx_max_digits10
1631 
1632 #endif // _GLIBCXX_NUMERIC_LIMITS