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 <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 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 9 : min() throw() { return -__SCHAR_MAX__ - 1; }
513 :
514 : static _GLIBCXX_CONSTEXPR signed char
515 15 : 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 14 : min() throw() { return 0; }
581 :
582 : static _GLIBCXX_CONSTEXPR unsigned char
583 17 : 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 2 : min() throw() { return 0; }
926 :
927 : static _GLIBCXX_CONSTEXPR unsigned short
928 16 : 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 640 : min() throw() { return -__INT_MAX__ - 1; }
995 :
996 : static _GLIBCXX_CONSTEXPR int
997 1283 : 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 635 : min() throw() { return 0; }
1062 :
1063 : static _GLIBCXX_CONSTEXPR unsigned int
1064 3236965 : 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 2 : 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
|
