File Coverage

/usr/include/c++/5/limits
Criterion Covered Total %
statement 1 1 100.0
branch n/a
condition n/a
subroutine n/a
pod n/a
total 1 1 100.0


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