libstdc++
limits
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 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 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 <gdr@codesourcery.com>
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 13 such types:
49 // * integers
50 // bool (1)
51 // char, signed char, unsigned char (3)
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 15 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) * 643 / 2136)
144 
145 
146 _GLIBCXX_BEGIN_NAMESPACE(std)
147 
148  /**
149  * @brief Describes the rounding style for floating-point types.
150  *
151  * This is used in the std::numeric_limits class.
152  */
153  enum float_round_style
154  {
155  round_indeterminate = -1, ///< Self-explanatory.
156  round_toward_zero = 0, ///< Self-explanatory.
157  round_to_nearest = 1, ///< To the nearest representable value.
158  round_toward_infinity = 2, ///< Self-explanatory.
159  round_toward_neg_infinity = 3 ///< Self-explanatory.
160  };
161 
162  /**
163  * @brief Describes the denormalization for floating-point types.
164  *
165  * These values represent the presence or absence of a variable number
166  * of exponent bits. This type is used in the std::numeric_limits class.
167  */
168  enum float_denorm_style
169  {
170  /// Indeterminate at compile time whether denormalized values are allowed.
171  denorm_indeterminate = -1,
172  /// The type does not allow denormalized values.
173  denorm_absent = 0,
174  /// The type allows denormalized values.
175  denorm_present = 1
176  };
177 
178  /**
179  * @brief Part of std::numeric_limits.
180  *
181  * The @c static @c const members are usable as integral constant
182  * expressions.
183  *
184  * @note This is a separate class for purposes of efficiency; you
185  * should only access these members as part of an instantiation
186  * of the std::numeric_limits class.
187  */
188  struct __numeric_limits_base
189  {
190  /** This will be true for all fundamental types (which have
191  specializations), and false for everything else. */
192  static const bool is_specialized = false;
193 
194  /** The number of @c radix digits that be represented without change: for
195  integer types, the number of non-sign bits in the mantissa; for
196  floating types, the number of @c radix digits in the mantissa. */
197  static const int digits = 0;
198  /** The number of base 10 digits that can be represented without change. */
199  static const int digits10 = 0;
200  /** True if the type is signed. */
201  static const bool is_signed = false;
202  /** True if the type is integer.
203  * Is this supposed to be "if the type is integral"?
204  */
205  static const bool is_integer = false;
206  /** True if the type uses an exact representation. "All integer types are
207  exact, but not all exact types are integer. For example, rational and
208  fixed-exponent representations are exact but not integer."
209  [18.2.1.2]/15 */
210  static const bool is_exact = false;
211  /** For integer types, specifies the base of the representation. For
212  floating types, specifies the base of the exponent representation. */
213  static const int radix = 0;
214 
215  /** The minimum negative integer such that @c radix raised to the power of
216  (one less than that integer) is a normalized floating point number. */
217  static const int min_exponent = 0;
218  /** The minimum negative integer such that 10 raised to that power is in
219  the range of normalized floating point numbers. */
220  static const int min_exponent10 = 0;
221  /** The maximum positive integer such that @c radix raised to the power of
222  (one less than that integer) is a representable finite floating point
223  number. */
224  static const int max_exponent = 0;
225  /** The maximum positive integer such that 10 raised to that power is in
226  the range of representable finite floating point numbers. */
227  static const int max_exponent10 = 0;
228 
229  /** True if the type has a representation for positive infinity. */
230  static const bool has_infinity = false;
231  /** True if the type has a representation for a quiet (non-signaling)
232  "Not a Number." */
233  static const bool has_quiet_NaN = false;
234  /** True if the type has a representation for a signaling
235  "Not a Number." */
236  static const bool has_signaling_NaN = false;
237  /** See std::float_denorm_style for more information. */
238  static const float_denorm_style has_denorm = denorm_absent;
239  /** "True if loss of accuracy is detected as a denormalization loss,
240  rather than as an inexact result." [18.2.1.2]/42 */
241  static const bool has_denorm_loss = false;
242 
243  /** True if-and-only-if the type adheres to the IEC 559 standard, also
244  known as IEEE 754. (Only makes sense for floating point types.) */
245  static const bool is_iec559 = false;
246  /** "True if the set of values representable by the type is finite. All
247  built-in types are bounded, this member would be false for arbitrary
248  precision types." [18.2.1.2]/54 */
249  static const bool is_bounded = false;
250  /** True if the type is @e modulo, that is, if it is possible to add two
251  positive numbers and have a result that wraps around to a third number
252  that is less. Typically false for floating types, true for unsigned
253  integers, and true for signed integers. */
254  static const bool is_modulo = false;
255 
256  /** True if trapping is implemented for this type. */
257  static const bool traps = false;
258  /** True if tininess is detected before rounding. (see IEC 559) */
259  static const bool tinyness_before = false;
260  /** See std::float_round_style for more information. This is only
261  meaningful for floating types; integer types will all be
262  round_toward_zero. */
263  static const float_round_style round_style = round_toward_zero;
264  };
265 
266  /**
267  * @brief Properties of fundamental types.
268  *
269  * This class allows a program to obtain information about the
270  * representation of a fundamental type on a given platform. For
271  * non-fundamental types, the functions will return 0 and the data
272  * members will all be @c false.
273  *
274  * _GLIBCXX_RESOLVE_LIB_DEFECTS: DRs 201 and 184 (hi Gaby!) are
275  * noted, but not incorporated in this documented (yet).
276  */
277  template<typename _Tp>
278  struct numeric_limits : public __numeric_limits_base
279  {
280  /** The minimum finite value, or for floating types with
281  denormalization, the minimum positive normalized value. */
282  static _Tp min() throw() { return static_cast<_Tp>(0); }
283  /** The maximum finite value. */
284  static _Tp max() throw() { return static_cast<_Tp>(0); }
285  /** The @e machine @e epsilon: the difference between 1 and the least
286  value greater than 1 that is representable. */
287  static _Tp epsilon() throw() { return static_cast<_Tp>(0); }
288  /** The maximum rounding error measurement (see LIA-1). */
289  static _Tp round_error() throw() { return static_cast<_Tp>(0); }
290  /** The representation of positive infinity, if @c has_infinity. */
291  static _Tp infinity() throw() { return static_cast<_Tp>(0); }
292  /** The representation of a quiet "Not a Number," if @c has_quiet_NaN. */
293  static _Tp quiet_NaN() throw() { return static_cast<_Tp>(0); }
294  /** The representation of a signaling "Not a Number," if
295  @c has_signaling_NaN. */
296  static _Tp signaling_NaN() throw() { return static_cast<_Tp>(0); }
297  /** The minimum positive denormalized value. For types where
298  @c has_denorm is false, this is the minimum positive normalized
299  value. */
300  static _Tp denorm_min() throw() { return static_cast<_Tp>(0); }
301  };
302 
303  // Now there follow 15 explicit specializations. Yes, 15. Make sure
304  // you get the count right.
305 
306  /// numeric_limits<bool> specialization.
307  template<>
308  struct numeric_limits<bool>
309  {
310  static const bool is_specialized = true;
311 
312  static bool min() throw()
313  { return false; }
314  static bool max() throw()
315  { return true; }
316 
317  static const int digits = 1;
318  static const int digits10 = 0;
319  static const bool is_signed = false;
320  static const bool is_integer = true;
321  static const bool is_exact = true;
322  static const int radix = 2;
323  static bool epsilon() throw()
324  { return false; }
325  static bool round_error() throw()
326  { return false; }
327 
328  static const int min_exponent = 0;
329  static const int min_exponent10 = 0;
330  static const int max_exponent = 0;
331  static const int max_exponent10 = 0;
332 
333  static const bool has_infinity = false;
334  static const bool has_quiet_NaN = false;
335  static const bool has_signaling_NaN = false;
336  static const float_denorm_style has_denorm = denorm_absent;
337  static const bool has_denorm_loss = false;
338 
339  static bool infinity() throw()
340  { return false; }
341  static bool quiet_NaN() throw()
342  { return false; }
343  static bool signaling_NaN() throw()
344  { return false; }
345  static bool denorm_min() throw()
346  { return false; }
347 
348  static const bool is_iec559 = false;
349  static const bool is_bounded = true;
350  static const bool is_modulo = false;
351 
352  // It is not clear what it means for a boolean type to trap.
353  // This is a DR on the LWG issue list. Here, I use integer
354  // promotion semantics.
355  static const bool traps = __glibcxx_integral_traps;
356  static const bool tinyness_before = false;
357  static const float_round_style round_style = round_toward_zero;
358  };
359 
360  /// numeric_limits<char> specialization.
361  template<>
362  struct numeric_limits<char>
363  {
364  static const bool is_specialized = true;
365 
366  static char min() throw()
367  { return __glibcxx_min(char); }
368  static char max() throw()
369  { return __glibcxx_max(char); }
370 
371  static const int digits = __glibcxx_digits (char);
372  static const int digits10 = __glibcxx_digits10 (char);
373  static const bool is_signed = __glibcxx_signed (char);
374  static const bool is_integer = true;
375  static const bool is_exact = true;
376  static const int radix = 2;
377  static char epsilon() throw()
378  { return 0; }
379  static char round_error() throw()
380  { return 0; }
381 
382  static const int min_exponent = 0;
383  static const int min_exponent10 = 0;
384  static const int max_exponent = 0;
385  static const int max_exponent10 = 0;
386 
387  static const bool has_infinity = false;
388  static const bool has_quiet_NaN = false;
389  static const bool has_signaling_NaN = false;
390  static const float_denorm_style has_denorm = denorm_absent;
391  static const bool has_denorm_loss = false;
392 
393  static char infinity() throw()
394  { return char(); }
395  static char quiet_NaN() throw()
396  { return char(); }
397  static char signaling_NaN() throw()
398  { return char(); }
399  static char denorm_min() throw()
400  { return static_cast<char>(0); }
401 
402  static const bool is_iec559 = false;
403  static const bool is_bounded = true;
404  static const bool is_modulo = true;
405 
406  static const bool traps = __glibcxx_integral_traps;
407  static const bool tinyness_before = false;
408  static const float_round_style round_style = round_toward_zero;
409  };
410 
411  /// numeric_limits<signed char> specialization.
412  template<>
413  struct numeric_limits<signed char>
414  {
415  static const bool is_specialized = true;
416 
417  static signed char min() throw()
418  { return -__SCHAR_MAX__ - 1; }
419  static signed char max() throw()
420  { return __SCHAR_MAX__; }
421 
422  static const int digits = __glibcxx_digits (signed char);
423  static const int digits10 = __glibcxx_digits10 (signed char);
424  static const bool is_signed = true;
425  static const bool is_integer = true;
426  static const bool is_exact = true;
427  static const int radix = 2;
428  static signed char epsilon() throw()
429  { return 0; }
430  static signed char round_error() throw()
431  { return 0; }
432 
433  static const int min_exponent = 0;
434  static const int min_exponent10 = 0;
435  static const int max_exponent = 0;
436  static const int max_exponent10 = 0;
437 
438  static const bool has_infinity = false;
439  static const bool has_quiet_NaN = false;
440  static const bool has_signaling_NaN = false;
441  static const float_denorm_style has_denorm = denorm_absent;
442  static const bool has_denorm_loss = false;
443 
444  static signed char infinity() throw()
445  { return static_cast<signed char>(0); }
446  static signed char quiet_NaN() throw()
447  { return static_cast<signed char>(0); }
448  static signed char signaling_NaN() throw()
449  { return static_cast<signed char>(0); }
450  static signed char denorm_min() throw()
451  { return static_cast<signed char>(0); }
452 
453  static const bool is_iec559 = false;
454  static const bool is_bounded = true;
455  static const bool is_modulo = true;
456 
457  static const bool traps = __glibcxx_integral_traps;
458  static const bool tinyness_before = false;
459  static const float_round_style round_style = round_toward_zero;
460  };
461 
462  /// numeric_limits<unsigned char> specialization.
463  template<>
464  struct numeric_limits<unsigned char>
465  {
466  static const bool is_specialized = true;
467 
468  static unsigned char min() throw()
469  { return 0; }
470  static unsigned char max() throw()
471  { return __SCHAR_MAX__ * 2U + 1; }
472 
473  static const int digits = __glibcxx_digits (unsigned char);
474  static const int digits10 = __glibcxx_digits10 (unsigned char);
475  static const bool is_signed = false;
476  static const bool is_integer = true;
477  static const bool is_exact = true;
478  static const int radix = 2;
479  static unsigned char epsilon() throw()
480  { return 0; }
481  static unsigned char round_error() throw()
482  { return 0; }
483 
484  static const int min_exponent = 0;
485  static const int min_exponent10 = 0;
486  static const int max_exponent = 0;
487  static const int max_exponent10 = 0;
488 
489  static const bool has_infinity = false;
490  static const bool has_quiet_NaN = false;
491  static const bool has_signaling_NaN = false;
492  static const float_denorm_style has_denorm = denorm_absent;
493  static const bool has_denorm_loss = false;
494 
495  static unsigned char infinity() throw()
496  { return static_cast<unsigned char>(0); }
497  static unsigned char quiet_NaN() throw()
498  { return static_cast<unsigned char>(0); }
499  static unsigned char signaling_NaN() throw()
500  { return static_cast<unsigned char>(0); }
501  static unsigned char denorm_min() throw()
502  { return static_cast<unsigned char>(0); }
503 
504  static const bool is_iec559 = false;
505  static const bool is_bounded = true;
506  static const bool is_modulo = true;
507 
508  static const bool traps = __glibcxx_integral_traps;
509  static const bool tinyness_before = false;
510  static const float_round_style round_style = round_toward_zero;
511  };
512 
513  /// numeric_limits<wchar_t> specialization.
514  template<>
515  struct numeric_limits<wchar_t>
516  {
517  static const bool is_specialized = true;
518 
519  static wchar_t min() throw()
520  { return __glibcxx_min (wchar_t); }
521  static wchar_t max() throw()
522  { return __glibcxx_max (wchar_t); }
523 
524  static const int digits = __glibcxx_digits (wchar_t);
525  static const int digits10 = __glibcxx_digits10 (wchar_t);
526  static const bool is_signed = __glibcxx_signed (wchar_t);
527  static const bool is_integer = true;
528  static const bool is_exact = true;
529  static const int radix = 2;
530  static wchar_t epsilon() throw()
531  { return 0; }
532  static wchar_t round_error() throw()
533  { return 0; }
534 
535  static const int min_exponent = 0;
536  static const int min_exponent10 = 0;
537  static const int max_exponent = 0;
538  static const int max_exponent10 = 0;
539 
540  static const bool has_infinity = false;
541  static const bool has_quiet_NaN = false;
542  static const bool has_signaling_NaN = false;
543  static const float_denorm_style has_denorm = denorm_absent;
544  static const bool has_denorm_loss = false;
545 
546  static wchar_t infinity() throw()
547  { return wchar_t(); }
548  static wchar_t quiet_NaN() throw()
549  { return wchar_t(); }
550  static wchar_t signaling_NaN() throw()
551  { return wchar_t(); }
552  static wchar_t denorm_min() throw()
553  { return wchar_t(); }
554 
555  static const bool is_iec559 = false;
556  static const bool is_bounded = true;
557  static const bool is_modulo = true;
558 
559  static const bool traps = __glibcxx_integral_traps;
560  static const bool tinyness_before = false;
561  static const float_round_style round_style = round_toward_zero;
562  };
563 
564 #ifdef __GXX_EXPERIMENTAL_CXX0X__
565  /// numeric_limits<char16_t> specialization.
566  template<>
567  struct numeric_limits<char16_t>
568  {
569  static const bool is_specialized = true;
570 
571  static char16_t min() throw()
572  { return __glibcxx_min (char16_t); }
573  static char16_t max() throw()
574  { return __glibcxx_max (char16_t); }
575 
576  static const int digits = __glibcxx_digits (char16_t);
577  static const int digits10 = __glibcxx_digits10 (char16_t);
578  static const bool is_signed = __glibcxx_signed (char16_t);
579  static const bool is_integer = true;
580  static const bool is_exact = true;
581  static const int radix = 2;
582  static char16_t epsilon() throw()
583  { return 0; }
584  static char16_t round_error() throw()
585  { return 0; }
586 
587  static const int min_exponent = 0;
588  static const int min_exponent10 = 0;
589  static const int max_exponent = 0;
590  static const int max_exponent10 = 0;
591 
592  static const bool has_infinity = false;
593  static const bool has_quiet_NaN = false;
594  static const bool has_signaling_NaN = false;
595  static const float_denorm_style has_denorm = denorm_absent;
596  static const bool has_denorm_loss = false;
597 
598  static char16_t infinity() throw()
599  { return char16_t(); }
600  static char16_t quiet_NaN() throw()
601  { return char16_t(); }
602  static char16_t signaling_NaN() throw()
603  { return char16_t(); }
604  static char16_t denorm_min() throw()
605  { return char16_t(); }
606 
607  static const bool is_iec559 = false;
608  static const bool is_bounded = true;
609  static const bool is_modulo = true;
610 
611  static const bool traps = __glibcxx_integral_traps;
612  static const bool tinyness_before = false;
613  static const float_round_style round_style = round_toward_zero;
614  };
615 
616  /// numeric_limits<char32_t> specialization.
617  template<>
618  struct numeric_limits<char32_t>
619  {
620  static const bool is_specialized = true;
621 
622  static char32_t min() throw()
623  { return __glibcxx_min (char32_t); }
624  static char32_t max() throw()
625  { return __glibcxx_max (char32_t); }
626 
627  static const int digits = __glibcxx_digits (char32_t);
628  static const int digits10 = __glibcxx_digits10 (char32_t);
629  static const bool is_signed = __glibcxx_signed (char32_t);
630  static const bool is_integer = true;
631  static const bool is_exact = true;
632  static const int radix = 2;
633  static char32_t epsilon() throw()
634  { return 0; }
635  static char32_t round_error() throw()
636  { return 0; }
637 
638  static const int min_exponent = 0;
639  static const int min_exponent10 = 0;
640  static const int max_exponent = 0;
641  static const int max_exponent10 = 0;
642 
643  static const bool has_infinity = false;
644  static const bool has_quiet_NaN = false;
645  static const bool has_signaling_NaN = false;
646  static const float_denorm_style has_denorm = denorm_absent;
647  static const bool has_denorm_loss = false;
648 
649  static char32_t infinity() throw()
650  { return char32_t(); }
651  static char32_t quiet_NaN() throw()
652  { return char32_t(); }
653  static char32_t signaling_NaN() throw()
654  { return char32_t(); }
655  static char32_t denorm_min() throw()
656  { return char32_t(); }
657 
658  static const bool is_iec559 = false;
659  static const bool is_bounded = true;
660  static const bool is_modulo = true;
661 
662  static const bool traps = __glibcxx_integral_traps;
663  static const bool tinyness_before = false;
664  static const float_round_style round_style = round_toward_zero;
665  };
666 #endif
667 
668  /// numeric_limits<short> specialization.
669  template<>
670  struct numeric_limits<short>
671  {
672  static const bool is_specialized = true;
673 
674  static short min() throw()
675  { return -__SHRT_MAX__ - 1; }
676  static short max() throw()
677  { return __SHRT_MAX__; }
678 
679  static const int digits = __glibcxx_digits (short);
680  static const int digits10 = __glibcxx_digits10 (short);
681  static const bool is_signed = true;
682  static const bool is_integer = true;
683  static const bool is_exact = true;
684  static const int radix = 2;
685  static short epsilon() throw()
686  { return 0; }
687  static short round_error() throw()
688  { return 0; }
689 
690  static const int min_exponent = 0;
691  static const int min_exponent10 = 0;
692  static const int max_exponent = 0;
693  static const int max_exponent10 = 0;
694 
695  static const bool has_infinity = false;
696  static const bool has_quiet_NaN = false;
697  static const bool has_signaling_NaN = false;
698  static const float_denorm_style has_denorm = denorm_absent;
699  static const bool has_denorm_loss = false;
700 
701  static short infinity() throw()
702  { return short(); }
703  static short quiet_NaN() throw()
704  { return short(); }
705  static short signaling_NaN() throw()
706  { return short(); }
707  static short denorm_min() throw()
708  { return short(); }
709 
710  static const bool is_iec559 = false;
711  static const bool is_bounded = true;
712  static const bool is_modulo = true;
713 
714  static const bool traps = __glibcxx_integral_traps;
715  static const bool tinyness_before = false;
716  static const float_round_style round_style = round_toward_zero;
717  };
718 
719  /// numeric_limits<unsigned short> specialization.
720  template<>
721  struct numeric_limits<unsigned short>
722  {
723  static const bool is_specialized = true;
724 
725  static unsigned short min() throw()
726  { return 0; }
727  static unsigned short max() throw()
728  { return __SHRT_MAX__ * 2U + 1; }
729 
730  static const int digits = __glibcxx_digits (unsigned short);
731  static const int digits10 = __glibcxx_digits10 (unsigned short);
732  static const bool is_signed = false;
733  static const bool is_integer = true;
734  static const bool is_exact = true;
735  static const int radix = 2;
736  static unsigned short epsilon() throw()
737  { return 0; }
738  static unsigned short round_error() throw()
739  { return 0; }
740 
741  static const int min_exponent = 0;
742  static const int min_exponent10 = 0;
743  static const int max_exponent = 0;
744  static const int max_exponent10 = 0;
745 
746  static const bool has_infinity = false;
747  static const bool has_quiet_NaN = false;
748  static const bool has_signaling_NaN = false;
749  static const float_denorm_style has_denorm = denorm_absent;
750  static const bool has_denorm_loss = false;
751 
752  static unsigned short infinity() throw()
753  { return static_cast<unsigned short>(0); }
754  static unsigned short quiet_NaN() throw()
755  { return static_cast<unsigned short>(0); }
756  static unsigned short signaling_NaN() throw()
757  { return static_cast<unsigned short>(0); }
758  static unsigned short denorm_min() throw()
759  { return static_cast<unsigned short>(0); }
760 
761  static const bool is_iec559 = false;
762  static const bool is_bounded = true;
763  static const bool is_modulo = true;
764 
765  static const bool traps = __glibcxx_integral_traps;
766  static const bool tinyness_before = false;
767  static const float_round_style round_style = round_toward_zero;
768  };
769 
770  /// numeric_limits<int> specialization.
771  template<>
772  struct numeric_limits<int>
773  {
774  static const bool is_specialized = true;
775 
776  static int min() throw()
777  { return -__INT_MAX__ - 1; }
778  static int max() throw()
779  { return __INT_MAX__; }
780 
781  static const int digits = __glibcxx_digits (int);
782  static const int digits10 = __glibcxx_digits10 (int);
783  static const bool is_signed = true;
784  static const bool is_integer = true;
785  static const bool is_exact = true;
786  static const int radix = 2;
787  static int epsilon() throw()
788  { return 0; }
789  static int round_error() throw()
790  { return 0; }
791 
792  static const int min_exponent = 0;
793  static const int min_exponent10 = 0;
794  static const int max_exponent = 0;
795  static const int max_exponent10 = 0;
796 
797  static const bool has_infinity = false;
798  static const bool has_quiet_NaN = false;
799  static const bool has_signaling_NaN = false;
800  static const float_denorm_style has_denorm = denorm_absent;
801  static const bool has_denorm_loss = false;
802 
803  static int infinity() throw()
804  { return static_cast<int>(0); }
805  static int quiet_NaN() throw()
806  { return static_cast<int>(0); }
807  static int signaling_NaN() throw()
808  { return static_cast<int>(0); }
809  static int denorm_min() throw()
810  { return static_cast<int>(0); }
811 
812  static const bool is_iec559 = false;
813  static const bool is_bounded = true;
814  static const bool is_modulo = true;
815 
816  static const bool traps = __glibcxx_integral_traps;
817  static const bool tinyness_before = false;
818  static const float_round_style round_style = round_toward_zero;
819  };
820 
821  /// numeric_limits<unsigned int> specialization.
822  template<>
823  struct numeric_limits<unsigned int>
824  {
825  static const bool is_specialized = true;
826 
827  static unsigned int min() throw()
828  { return 0; }
829  static unsigned int max() throw()
830  { return __INT_MAX__ * 2U + 1; }
831 
832  static const int digits = __glibcxx_digits (unsigned int);
833  static const int digits10 = __glibcxx_digits10 (unsigned int);
834  static const bool is_signed = false;
835  static const bool is_integer = true;
836  static const bool is_exact = true;
837  static const int radix = 2;
838  static unsigned int epsilon() throw()
839  { return 0; }
840  static unsigned int round_error() throw()
841  { return 0; }
842 
843  static const int min_exponent = 0;
844  static const int min_exponent10 = 0;
845  static const int max_exponent = 0;
846  static const int max_exponent10 = 0;
847 
848  static const bool has_infinity = false;
849  static const bool has_quiet_NaN = false;
850  static const bool has_signaling_NaN = false;
851  static const float_denorm_style has_denorm = denorm_absent;
852  static const bool has_denorm_loss = false;
853 
854  static unsigned int infinity() throw()
855  { return static_cast<unsigned int>(0); }
856  static unsigned int quiet_NaN() throw()
857  { return static_cast<unsigned int>(0); }
858  static unsigned int signaling_NaN() throw()
859  { return static_cast<unsigned int>(0); }
860  static unsigned int denorm_min() throw()
861  { return static_cast<unsigned int>(0); }
862 
863  static const bool is_iec559 = false;
864  static const bool is_bounded = true;
865  static const bool is_modulo = true;
866 
867  static const bool traps = __glibcxx_integral_traps;
868  static const bool tinyness_before = false;
869  static const float_round_style round_style = round_toward_zero;
870  };
871 
872  /// numeric_limits<long> specialization.
873  template<>
874  struct numeric_limits<long>
875  {
876  static const bool is_specialized = true;
877 
878  static long min() throw()
879  { return -__LONG_MAX__ - 1; }
880  static long max() throw()
881  { return __LONG_MAX__; }
882 
883  static const int digits = __glibcxx_digits (long);
884  static const int digits10 = __glibcxx_digits10 (long);
885  static const bool is_signed = true;
886  static const bool is_integer = true;
887  static const bool is_exact = true;
888  static const int radix = 2;
889  static long epsilon() throw()
890  { return 0; }
891  static long round_error() throw()
892  { return 0; }
893 
894  static const int min_exponent = 0;
895  static const int min_exponent10 = 0;
896  static const int max_exponent = 0;
897  static const int max_exponent10 = 0;
898 
899  static const bool has_infinity = false;
900  static const bool has_quiet_NaN = false;
901  static const bool has_signaling_NaN = false;
902  static const float_denorm_style has_denorm = denorm_absent;
903  static const bool has_denorm_loss = false;
904 
905  static long infinity() throw()
906  { return static_cast<long>(0); }
907  static long quiet_NaN() throw()
908  { return static_cast<long>(0); }
909  static long signaling_NaN() throw()
910  { return static_cast<long>(0); }
911  static long denorm_min() throw()
912  { return static_cast<long>(0); }
913 
914  static const bool is_iec559 = false;
915  static const bool is_bounded = true;
916  static const bool is_modulo = true;
917 
918  static const bool traps = __glibcxx_integral_traps;
919  static const bool tinyness_before = false;
920  static const float_round_style round_style = round_toward_zero;
921  };
922 
923  /// numeric_limits<unsigned long> specialization.
924  template<>
925  struct numeric_limits<unsigned long>
926  {
927  static const bool is_specialized = true;
928 
929  static unsigned long min() throw()
930  { return 0; }
931  static unsigned long max() throw()
932  { return __LONG_MAX__ * 2UL + 1; }
933 
934  static const int digits = __glibcxx_digits (unsigned long);
935  static const int digits10 = __glibcxx_digits10 (unsigned long);
936  static const bool is_signed = false;
937  static const bool is_integer = true;
938  static const bool is_exact = true;
939  static const int radix = 2;
940  static unsigned long epsilon() throw()
941  { return 0; }
942  static unsigned long round_error() throw()
943  { return 0; }
944 
945  static const int min_exponent = 0;
946  static const int min_exponent10 = 0;
947  static const int max_exponent = 0;
948  static const int max_exponent10 = 0;
949 
950  static const bool has_infinity = false;
951  static const bool has_quiet_NaN = false;
952  static const bool has_signaling_NaN = false;
953  static const float_denorm_style has_denorm = denorm_absent;
954  static const bool has_denorm_loss = false;
955 
956  static unsigned long infinity() throw()
957  { return static_cast<unsigned long>(0); }
958  static unsigned long quiet_NaN() throw()
959  { return static_cast<unsigned long>(0); }
960  static unsigned long signaling_NaN() throw()
961  { return static_cast<unsigned long>(0); }
962  static unsigned long denorm_min() throw()
963  { return static_cast<unsigned long>(0); }
964 
965  static const bool is_iec559 = false;
966  static const bool is_bounded = true;
967  static const bool is_modulo = true;
968 
969  static const bool traps = __glibcxx_integral_traps;
970  static const bool tinyness_before = false;
971  static const float_round_style round_style = round_toward_zero;
972  };
973 
974  /// numeric_limits<long long> specialization.
975  template<>
976  struct numeric_limits<long long>
977  {
978  static const bool is_specialized = true;
979 
980  static long long min() throw()
981  { return -__LONG_LONG_MAX__ - 1; }
982  static long long max() throw()
983  { return __LONG_LONG_MAX__; }
984 
985  static const int digits = __glibcxx_digits (long long);
986  static const int digits10 = __glibcxx_digits10 (long long);
987  static const bool is_signed = true;
988  static const bool is_integer = true;
989  static const bool is_exact = true;
990  static const int radix = 2;
991  static long long epsilon() throw()
992  { return 0; }
993  static long long round_error() throw()
994  { return 0; }
995 
996  static const int min_exponent = 0;
997  static const int min_exponent10 = 0;
998  static const int max_exponent = 0;
999  static const int max_exponent10 = 0;
1000 
1001  static const bool has_infinity = false;
1002  static const bool has_quiet_NaN = false;
1003  static const bool has_signaling_NaN = false;
1004  static const float_denorm_style has_denorm = denorm_absent;
1005  static const bool has_denorm_loss = false;
1006 
1007  static long long infinity() throw()
1008  { return static_cast<long long>(0); }
1009  static long long quiet_NaN() throw()
1010  { return static_cast<long long>(0); }
1011  static long long signaling_NaN() throw()
1012  { return static_cast<long long>(0); }
1013  static long long denorm_min() throw()
1014  { return static_cast<long long>(0); }
1015 
1016  static const bool is_iec559 = false;
1017  static const bool is_bounded = true;
1018  static const bool is_modulo = true;
1019 
1020  static const bool traps = __glibcxx_integral_traps;
1021  static const bool tinyness_before = false;
1022  static const float_round_style round_style = round_toward_zero;
1023  };
1024 
1025  /// numeric_limits<unsigned long long> specialization.
1026  template<>
1027  struct numeric_limits<unsigned long long>
1028  {
1029  static const bool is_specialized = true;
1030 
1031  static unsigned long long min() throw()
1032  { return 0; }
1033  static unsigned long long max() throw()
1034  { return __LONG_LONG_MAX__ * 2ULL + 1; }
1035 
1036  static const int digits = __glibcxx_digits (unsigned long long);
1037  static const int digits10 = __glibcxx_digits10 (unsigned long long);
1038  static const bool is_signed = false;
1039  static const bool is_integer = true;
1040  static const bool is_exact = true;
1041  static const int radix = 2;
1042  static unsigned long long epsilon() throw()
1043  { return 0; }
1044  static unsigned long long round_error() throw()
1045  { return 0; }
1046 
1047  static const int min_exponent = 0;
1048  static const int min_exponent10 = 0;
1049  static const int max_exponent = 0;
1050  static const int max_exponent10 = 0;
1051 
1052  static const bool has_infinity = false;
1053  static const bool has_quiet_NaN = false;
1054  static const bool has_signaling_NaN = false;
1055  static const float_denorm_style has_denorm = denorm_absent;
1056  static const bool has_denorm_loss = false;
1057 
1058  static unsigned long long infinity() throw()
1059  { return static_cast<unsigned long long>(0); }
1060  static unsigned long long quiet_NaN() throw()
1061  { return static_cast<unsigned long long>(0); }
1062  static unsigned long long signaling_NaN() throw()
1063  { return static_cast<unsigned long long>(0); }
1064  static unsigned long long denorm_min() throw()
1065  { return static_cast<unsigned long long>(0); }
1066 
1067  static const bool is_iec559 = false;
1068  static const bool is_bounded = true;
1069  static const bool is_modulo = true;
1070 
1071  static const bool traps = __glibcxx_integral_traps;
1072  static const bool tinyness_before = false;
1073  static const float_round_style round_style = round_toward_zero;
1074  };
1075 
1076  /// numeric_limits<float> specialization.
1077  template<>
1078  struct numeric_limits<float>
1079  {
1080  static const bool is_specialized = true;
1081 
1082  static float min() throw()
1083  { return __FLT_MIN__; }
1084  static float max() throw()
1085  { return __FLT_MAX__; }
1086 
1087  static const int digits = __FLT_MANT_DIG__;
1088  static const int digits10 = __FLT_DIG__;
1089  static const bool is_signed = true;
1090  static const bool is_integer = false;
1091  static const bool is_exact = false;
1092  static const int radix = __FLT_RADIX__;
1093  static float epsilon() throw()
1094  { return __FLT_EPSILON__; }
1095  static float round_error() throw()
1096  { return 0.5F; }
1097 
1098  static const int min_exponent = __FLT_MIN_EXP__;
1099  static const int min_exponent10 = __FLT_MIN_10_EXP__;
1100  static const int max_exponent = __FLT_MAX_EXP__;
1101  static const int max_exponent10 = __FLT_MAX_10_EXP__;
1102 
1103  static const bool has_infinity = __FLT_HAS_INFINITY__;
1104  static const bool has_quiet_NaN = __FLT_HAS_QUIET_NAN__;
1105  static const bool has_signaling_NaN = has_quiet_NaN;
1106  static const float_denorm_style has_denorm
1107  = bool(__FLT_HAS_DENORM__) ? denorm_present : denorm_absent;
1108  static const bool has_denorm_loss = __glibcxx_float_has_denorm_loss;
1109 
1110  static float infinity() throw()
1111  { return __builtin_huge_valf (); }
1112  static float quiet_NaN() throw()
1113  { return __builtin_nanf (""); }
1114  static float signaling_NaN() throw()
1115  { return __builtin_nansf (""); }
1116  static float denorm_min() throw()
1117  { return __FLT_DENORM_MIN__; }
1118 
1119  static const bool is_iec559
1120  = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
1121  static const bool is_bounded = true;
1122  static const bool is_modulo = false;
1123 
1124  static const bool traps = __glibcxx_float_traps;
1125  static const bool tinyness_before = __glibcxx_float_tinyness_before;
1126  static const float_round_style round_style = round_to_nearest;
1127  };
1128 
1129 #undef __glibcxx_float_has_denorm_loss
1130 #undef __glibcxx_float_traps
1131 #undef __glibcxx_float_tinyness_before
1132 
1133  /// numeric_limits<double> specialization.
1134  template<>
1135  struct numeric_limits<double>
1136  {
1137  static const bool is_specialized = true;
1138 
1139  static double min() throw()
1140  { return __DBL_MIN__; }
1141  static double max() throw()
1142  { return __DBL_MAX__; }
1143 
1144  static const int digits = __DBL_MANT_DIG__;
1145  static const int digits10 = __DBL_DIG__;
1146  static const bool is_signed = true;
1147  static const bool is_integer = false;
1148  static const bool is_exact = false;
1149  static const int radix = __FLT_RADIX__;
1150  static double epsilon() throw()
1151  { return __DBL_EPSILON__; }
1152  static double round_error() throw()
1153  { return 0.5; }
1154 
1155  static const int min_exponent = __DBL_MIN_EXP__;
1156  static const int min_exponent10 = __DBL_MIN_10_EXP__;
1157  static const int max_exponent = __DBL_MAX_EXP__;
1158  static const int max_exponent10 = __DBL_MAX_10_EXP__;
1159 
1160  static const bool has_infinity = __DBL_HAS_INFINITY__;
1161  static const bool has_quiet_NaN = __DBL_HAS_QUIET_NAN__;
1162  static const bool has_signaling_NaN = has_quiet_NaN;
1163  static const float_denorm_style has_denorm
1164  = bool(__DBL_HAS_DENORM__) ? denorm_present : denorm_absent;
1165  static const bool has_denorm_loss = __glibcxx_double_has_denorm_loss;
1166 
1167  static double infinity() throw()
1168  { return __builtin_huge_val(); }
1169  static double quiet_NaN() throw()
1170  { return __builtin_nan (""); }
1171  static double signaling_NaN() throw()
1172  { return __builtin_nans (""); }
1173  static double denorm_min() throw()
1174  { return __DBL_DENORM_MIN__; }
1175 
1176  static const bool is_iec559
1177  = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
1178  static const bool is_bounded = true;
1179  static const bool is_modulo = false;
1180 
1181  static const bool traps = __glibcxx_double_traps;
1182  static const bool tinyness_before = __glibcxx_double_tinyness_before;
1183  static const float_round_style round_style = round_to_nearest;
1184  };
1185 
1186 #undef __glibcxx_double_has_denorm_loss
1187 #undef __glibcxx_double_traps
1188 #undef __glibcxx_double_tinyness_before
1189 
1190  /// numeric_limits<long double> specialization.
1191  template<>
1192  struct numeric_limits<long double>
1193  {
1194  static const bool is_specialized = true;
1195 
1196  static long double min() throw()
1197  { return __LDBL_MIN__; }
1198  static long double max() throw()
1199  { return __LDBL_MAX__; }
1200 
1201  static const int digits = __LDBL_MANT_DIG__;
1202  static const int digits10 = __LDBL_DIG__;
1203  static const bool is_signed = true;
1204  static const bool is_integer = false;
1205  static const bool is_exact = false;
1206  static const int radix = __FLT_RADIX__;
1207  static long double epsilon() throw()
1208  { return __LDBL_EPSILON__; }
1209  static long double round_error() throw()
1210  { return 0.5L; }
1211 
1212  static const int min_exponent = __LDBL_MIN_EXP__;
1213  static const int min_exponent10 = __LDBL_MIN_10_EXP__;
1214  static const int max_exponent = __LDBL_MAX_EXP__;
1215  static const int max_exponent10 = __LDBL_MAX_10_EXP__;
1216 
1217  static const bool has_infinity = __LDBL_HAS_INFINITY__;
1218  static const bool has_quiet_NaN = __LDBL_HAS_QUIET_NAN__;
1219  static const bool has_signaling_NaN = has_quiet_NaN;
1220  static const float_denorm_style has_denorm
1221  = bool(__LDBL_HAS_DENORM__) ? denorm_present : denorm_absent;
1222  static const bool has_denorm_loss
1223  = __glibcxx_long_double_has_denorm_loss;
1224 
1225  static long double infinity() throw()
1226  { return __builtin_huge_vall (); }
1227  static long double quiet_NaN() throw()
1228  { return __builtin_nanl (""); }
1229  static long double signaling_NaN() throw()
1230  { return __builtin_nansl (""); }
1231  static long double denorm_min() throw()
1232  { return __LDBL_DENORM_MIN__; }
1233 
1234  static const bool is_iec559
1235  = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
1236  static const bool is_bounded = true;
1237  static const bool is_modulo = false;
1238 
1239  static const bool traps = __glibcxx_long_double_traps;
1240  static const bool tinyness_before = __glibcxx_long_double_tinyness_before;
1241  static const float_round_style round_style = round_to_nearest;
1242  };
1243 
1244 #undef __glibcxx_long_double_has_denorm_loss
1245 #undef __glibcxx_long_double_traps
1246 #undef __glibcxx_long_double_tinyness_before
1247 
1248 _GLIBCXX_END_NAMESPACE
1249 
1250 #undef __glibcxx_signed
1251 #undef __glibcxx_min
1252 #undef __glibcxx_max
1253 #undef __glibcxx_digits
1254 #undef __glibcxx_digits10
1255 
1256 #endif // _GLIBCXX_NUMERIC_LIMITS