1// The template and inlines for the numeric_limits classes. -*- C++ -*- 
2 
3// Copyright (C) 1999-2019 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 
158namespace 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 template<typename _Tp> 
312 struct numeric_limits : public __numeric_limits_base 
313 { 
314 /** The minimum finite value, or for floating types with 
315 denormalization, the minimum positive normalized value. */ 
316 static _GLIBCXX_CONSTEXPR _Tp 
317 min() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } 
318 
319 /** The maximum finite value. */ 
320 static _GLIBCXX_CONSTEXPR _Tp 
321 max() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } 
322 
323#if __cplusplus >= 201103L 
324 /** A finite value x such that there is no other finite value y 
325 * where y < x. */ 
326 static constexpr _Tp 
327 lowest() noexcept { return _Tp(); } 
328#endif 
329 
330 /** The @e machine @e epsilon: the difference between 1 and the least 
331 value greater than 1 that is representable. */ 
332 static _GLIBCXX_CONSTEXPR _Tp 
333 epsilon() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } 
334 
335 /** The maximum rounding error measurement (see LIA-1). */ 
336 static _GLIBCXX_CONSTEXPR _Tp 
337 round_error() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } 
338 
339 /** The representation of positive infinity, if @c has_infinity. */ 
340 static _GLIBCXX_CONSTEXPR _Tp 
341 infinity() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } 
342 
343 /** The representation of a quiet Not a Number, 
344 if @c has_quiet_NaN. */ 
345 static _GLIBCXX_CONSTEXPR _Tp 
346 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } 
347 
348 /** The representation of a signaling Not a Number, if 
349 @c has_signaling_NaN. */ 
350 static _GLIBCXX_CONSTEXPR _Tp 
351 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } 
352 
353 /** The minimum positive denormalized value. For types where 
354 @c has_denorm is false, this is the minimum positive normalized 
355 value. */ 
356 static _GLIBCXX_CONSTEXPR _Tp 
357 denorm_min() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } 
358 }; 
359 
360 // _GLIBCXX_RESOLVE_LIB_DEFECTS 
361 // 559. numeric_limits<const T> 
362 
363 template<typename _Tp> 
364 struct numeric_limits<const _Tp> 
365 : public numeric_limits<_Tp> { }; 
366 
367 template<typename _Tp> 
368 struct numeric_limits<volatile _Tp> 
369 : public numeric_limits<_Tp> { }; 
370 
371 template<typename _Tp> 
372 struct numeric_limits<const volatile _Tp> 
373 : public numeric_limits<_Tp> { }; 
374 
375 // Now there follow 16 explicit specializations. Yes, 16. Make sure 
376 // you get the count right. (18 in C++11 mode, with char16_t and char32_t.) 
377 // (+1 if char8_t is enabled.) 
378 
379 // _GLIBCXX_RESOLVE_LIB_DEFECTS 
380 // 184. numeric_limits<bool> wording problems 
381 
382 /// numeric_limits<bool> specialization. 
383 template<> 
384 struct numeric_limits<bool> 
385 { 
386 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 
387 
388 static _GLIBCXX_CONSTEXPR bool 
389 min() _GLIBCXX_USE_NOEXCEPT { return false; } 
390 
391 static _GLIBCXX_CONSTEXPR bool 
392 max() _GLIBCXX_USE_NOEXCEPT { return true; } 
393 
394#if __cplusplus >= 201103L 
395 static constexpr bool 
396 lowest() noexcept { return min(); } 
397#endif 
398 static _GLIBCXX_USE_CONSTEXPR int digits = 1; 
399 static _GLIBCXX_USE_CONSTEXPR int digits10 = 0; 
400#if __cplusplus >= 201103L 
401 static constexpr int max_digits10 = 0; 
402#endif 
403 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 
404 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 
405 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 
406 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 
407 
408 static _GLIBCXX_CONSTEXPR bool 
409 epsilon() _GLIBCXX_USE_NOEXCEPT { return false; } 
410 
411 static _GLIBCXX_CONSTEXPR bool 
412 round_error() _GLIBCXX_USE_NOEXCEPT { return false; } 
413 
414 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 
415 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 
416 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 
417 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 
418 
419 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 
420 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 
421 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 
422 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 
423 = denorm_absent; 
424 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 
425 
426 static _GLIBCXX_CONSTEXPR bool 
427 infinity() _GLIBCXX_USE_NOEXCEPT { return false; } 
428 
429 static _GLIBCXX_CONSTEXPR bool 
430 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return false; } 
431 
432 static _GLIBCXX_CONSTEXPR bool 
433 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return false; } 
434 
435 static _GLIBCXX_CONSTEXPR bool 
436 denorm_min() _GLIBCXX_USE_NOEXCEPT { return false; } 
437 
438 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 
439 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 
440 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 
441 
442 // It is not clear what it means for a boolean type to trap. 
443 // This is a DR on the LWG issue list. Here, I use integer 
444 // promotion semantics. 
445 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 
446 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 
447 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 
448 = round_toward_zero; 
449 }; 
450 
451 /// numeric_limits<char> specialization. 
452 template<> 
453 struct numeric_limits<char> 
454 { 
455 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 
456 
457 static _GLIBCXX_CONSTEXPR char 
458 min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min(char); } 
459 
460 static _GLIBCXX_CONSTEXPR char 
461 max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max(char); } 
462 
463#if __cplusplus >= 201103L 
464 static constexpr char 
465 lowest() noexcept { return min(); } 
466#endif 
467 
468 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (char); 
469 static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (char); 
470#if __cplusplus >= 201103L 
471 static constexpr int max_digits10 = 0; 
472#endif 
473 static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (char); 
474 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 
475 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 
476 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 
477 
478 static _GLIBCXX_CONSTEXPR char 
479 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 
480 
481 static _GLIBCXX_CONSTEXPR char 
482 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 
483 
484 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 
485 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 
486 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 
487 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 
488 
489 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 
490 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 
491 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 
492 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 
493 = denorm_absent; 
494 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 
495 
496 static _GLIBCXX_CONSTEXPR 
497 char infinity() _GLIBCXX_USE_NOEXCEPT { return char(); } 
498 
499 static _GLIBCXX_CONSTEXPR char 
500 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return char(); } 
501 
502 static _GLIBCXX_CONSTEXPR char 
503 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return char(); } 
504 
505 static _GLIBCXX_CONSTEXPR char 
506 denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<char>(0); } 
507 
508 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 
509 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 
510 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = !is_signed; 
511 
512 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 
513 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 
514 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 
515 = round_toward_zero; 
516 }; 
517 
518 /// numeric_limits<signed char> specialization. 
519 template<> 
520 struct numeric_limits<signed char> 
521 { 
522 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 
523 
524 static _GLIBCXX_CONSTEXPR signed char 
525 min() _GLIBCXX_USE_NOEXCEPT { return -__SCHAR_MAX__ - 1; } 
526 
527 static _GLIBCXX_CONSTEXPR signed char 
528 max() _GLIBCXX_USE_NOEXCEPT { return __SCHAR_MAX__; } 
529 
530#if __cplusplus >= 201103L 
531 static constexpr signed char 
532 lowest() noexcept { return min(); } 
533#endif 
534 
535 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (signed char); 
536 static _GLIBCXX_USE_CONSTEXPR int digits10 
537 = __glibcxx_digits10 (signed char); 
538#if __cplusplus >= 201103L 
539 static constexpr int max_digits10 = 0; 
540#endif 
541 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 
542 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 
543 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 
544 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 
545 
546 static _GLIBCXX_CONSTEXPR signed char 
547 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 
548 
549 static _GLIBCXX_CONSTEXPR signed char 
550 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 
551 
552 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 
553 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 
554 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 
555 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 
556 
557 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 
558 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 
559 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 
560 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 
561 = denorm_absent; 
562 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 
563 
564 static _GLIBCXX_CONSTEXPR signed char 
565 infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<signed char>(0); } 
566 
567 static _GLIBCXX_CONSTEXPR signed char 
568 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<signed char>(0); } 
569 
570 static _GLIBCXX_CONSTEXPR signed char 
571 signaling_NaN() _GLIBCXX_USE_NOEXCEPT 
572 { return static_cast<signed char>(0); } 
573 
574 static _GLIBCXX_CONSTEXPR signed char 
575 denorm_min() _GLIBCXX_USE_NOEXCEPT 
576 { return static_cast<signed char>(0); } 
577 
578 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 
579 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 
580 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 
581 
582 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 
583 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 
584 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 
585 = round_toward_zero; 
586 }; 
587 
588 /// numeric_limits<unsigned char> specialization. 
589 template<> 
590 struct numeric_limits<unsigned char> 
591 { 
592 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 
593 
594 static _GLIBCXX_CONSTEXPR unsigned char 
595 min() _GLIBCXX_USE_NOEXCEPT { return 0; } 
596 
597 static _GLIBCXX_CONSTEXPR unsigned char 
598 max() _GLIBCXX_USE_NOEXCEPT { return __SCHAR_MAX__ * 2U + 1; } 
599 
600#if __cplusplus >= 201103L 
601 static constexpr unsigned char 
602 lowest() noexcept { return min(); } 
603#endif 
604 
605 static _GLIBCXX_USE_CONSTEXPR int digits 
606 = __glibcxx_digits (unsigned char); 
607 static _GLIBCXX_USE_CONSTEXPR int digits10 
608 = __glibcxx_digits10 (unsigned char); 
609#if __cplusplus >= 201103L 
610 static constexpr int max_digits10 = 0; 
611#endif 
612 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 
613 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 
614 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 
615 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 
616 
617 static _GLIBCXX_CONSTEXPR unsigned char 
618 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 
619 
620 static _GLIBCXX_CONSTEXPR unsigned char 
621 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 
622 
623 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 
624 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 
625 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 
626 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 
627 
628 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 
629 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 
630 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 
631 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 
632 = denorm_absent; 
633 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 
634 
635 static _GLIBCXX_CONSTEXPR unsigned char 
636 infinity() _GLIBCXX_USE_NOEXCEPT 
637 { return static_cast<unsigned char>(0); } 
638 
639 static _GLIBCXX_CONSTEXPR unsigned char 
640 quiet_NaN() _GLIBCXX_USE_NOEXCEPT 
641 { return static_cast<unsigned char>(0); } 
642 
643 static _GLIBCXX_CONSTEXPR unsigned char 
644 signaling_NaN() _GLIBCXX_USE_NOEXCEPT 
645 { return static_cast<unsigned char>(0); } 
646 
647 static _GLIBCXX_CONSTEXPR unsigned char 
648 denorm_min() _GLIBCXX_USE_NOEXCEPT 
649 { return static_cast<unsigned char>(0); } 
650 
651 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 
652 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 
653 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 
654 
655 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 
656 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 
657 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 
658 = round_toward_zero; 
659 }; 
660 
661 /// numeric_limits<wchar_t> specialization. 
662 template<> 
663 struct numeric_limits<wchar_t> 
664 { 
665 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 
666 
667 static _GLIBCXX_CONSTEXPR wchar_t 
668 min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min (wchar_t); } 
669 
670 static _GLIBCXX_CONSTEXPR wchar_t 
671 max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max (wchar_t); } 
672 
673#if __cplusplus >= 201103L 
674 static constexpr wchar_t 
675 lowest() noexcept { return min(); } 
676#endif 
677 
678 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (wchar_t); 
679 static _GLIBCXX_USE_CONSTEXPR int digits10 
680 = __glibcxx_digits10 (wchar_t); 
681#if __cplusplus >= 201103L 
682 static constexpr int max_digits10 = 0; 
683#endif 
684 static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (wchar_t); 
685 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 
686 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 
687 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 
688 
689 static _GLIBCXX_CONSTEXPR wchar_t 
690 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 
691 
692 static _GLIBCXX_CONSTEXPR wchar_t 
693 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 
694 
695 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 
696 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 
697 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 
698 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 
699 
700 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 
701 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 
702 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 
703 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 
704 = denorm_absent; 
705 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 
706 
707 static _GLIBCXX_CONSTEXPR wchar_t 
708 infinity() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); } 
709 
710 static _GLIBCXX_CONSTEXPR wchar_t 
711 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); } 
712 
713 static _GLIBCXX_CONSTEXPR wchar_t 
714 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); } 
715 
716 static _GLIBCXX_CONSTEXPR wchar_t 
717 denorm_min() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); } 
718 
719 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 
720 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 
721 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = !is_signed; 
722 
723 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 
724 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 
725 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 
726 = round_toward_zero; 
727 }; 
728 
729#if _GLIBCXX_USE_CHAR8_T 
730 /// numeric_limits<char8_t> specialization. 
731 template<> 
732 struct numeric_limits<char8_t> 
733 { 
734 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 
735 
736 static _GLIBCXX_CONSTEXPR char8_t 
737 min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min (char8_t); } 
738 
739 static _GLIBCXX_CONSTEXPR char8_t 
740 max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max (char8_t); } 
741 
742 static _GLIBCXX_CONSTEXPR char8_t 
743 lowest() _GLIBCXX_USE_NOEXCEPT { return min(); } 
744 
745 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (char8_t); 
746 static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (char8_t); 
747 static _GLIBCXX_USE_CONSTEXPR int max_digits10 = 0; 
748 static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (char8_t); 
749 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 
750 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 
751 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 
752 
753 static _GLIBCXX_CONSTEXPR char8_t 
754 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 
755 
756 static _GLIBCXX_CONSTEXPR char8_t 
757 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 
758 
759 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 
760 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 
761 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 
762 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 
763 
764 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 
765 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 
766 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 
767 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 
768 = denorm_absent; 
769 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 
770 
771 static _GLIBCXX_CONSTEXPR char8_t 
772 infinity() _GLIBCXX_USE_NOEXCEPT { return char8_t(); } 
773 
774 static _GLIBCXX_CONSTEXPR char8_t 
775 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return char8_t(); } 
776 
777 static _GLIBCXX_CONSTEXPR char8_t 
778 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return char8_t(); } 
779 
780 static _GLIBCXX_CONSTEXPR char8_t 
781 denorm_min() _GLIBCXX_USE_NOEXCEPT { return char8_t(); } 
782 
783 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 
784 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 
785 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = !is_signed; 
786 
787 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 
788 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 
789 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 
790 = round_toward_zero; 
791 }; 
792#endif 
793 
794#if __cplusplus >= 201103L 
795 /// numeric_limits<char16_t> specialization. 
796 template<> 
797 struct numeric_limits<char16_t> 
798 { 
799 static constexpr bool is_specialized = true; 
800 
801 static constexpr char16_t 
802 min() noexcept { return __glibcxx_min (char16_t); } 
803 
804 static constexpr char16_t 
805 max() noexcept { return __glibcxx_max (char16_t); } 
806 
807 static constexpr char16_t 
808 lowest() noexcept { return min(); } 
809 
810 static constexpr int digits = __glibcxx_digits (char16_t); 
811 static constexpr int digits10 = __glibcxx_digits10 (char16_t); 
812 static constexpr int max_digits10 = 0; 
813 static constexpr bool is_signed = __glibcxx_signed (char16_t); 
814 static constexpr bool is_integer = true; 
815 static constexpr bool is_exact = true; 
816 static constexpr int radix = 2; 
817 
818 static constexpr char16_t 
819 epsilon() noexcept { return 0; } 
820 
821 static constexpr char16_t 
822 round_error() noexcept { return 0; } 
823 
824 static constexpr int min_exponent = 0; 
825 static constexpr int min_exponent10 = 0; 
826 static constexpr int max_exponent = 0; 
827 static constexpr int max_exponent10 = 0; 
828 
829 static constexpr bool has_infinity = false; 
830 static constexpr bool has_quiet_NaN = false; 
831 static constexpr bool has_signaling_NaN = false; 
832 static constexpr float_denorm_style has_denorm = denorm_absent; 
833 static constexpr bool has_denorm_loss = false; 
834 
835 static constexpr char16_t 
836 infinity() noexcept { return char16_t(); } 
837 
838 static constexpr char16_t 
839 quiet_NaN() noexcept { return char16_t(); } 
840 
841 static constexpr char16_t 
842 signaling_NaN() noexcept { return char16_t(); } 
843 
844 static constexpr char16_t 
845 denorm_min() noexcept { return char16_t(); } 
846 
847 static constexpr bool is_iec559 = false; 
848 static constexpr bool is_bounded = true; 
849 static constexpr bool is_modulo = !is_signed; 
850 
851 static constexpr bool traps = __glibcxx_integral_traps; 
852 static constexpr bool tinyness_before = false; 
853 static constexpr float_round_style round_style = round_toward_zero; 
854 }; 
855 
856 /// numeric_limits<char32_t> specialization. 
857 template<> 
858 struct numeric_limits<char32_t> 
859 { 
860 static constexpr bool is_specialized = true; 
861 
862 static constexpr char32_t 
863 min() noexcept { return __glibcxx_min (char32_t); } 
864 
865 static constexpr char32_t 
866 max() noexcept { return __glibcxx_max (char32_t); } 
867 
868 static constexpr char32_t 
869 lowest() noexcept { return min(); } 
870 
871 static constexpr int digits = __glibcxx_digits (char32_t); 
872 static constexpr int digits10 = __glibcxx_digits10 (char32_t); 
873 static constexpr int max_digits10 = 0; 
874 static constexpr bool is_signed = __glibcxx_signed (char32_t); 
875 static constexpr bool is_integer = true; 
876 static constexpr bool is_exact = true; 
877 static constexpr int radix = 2; 
878 
879 static constexpr char32_t 
880 epsilon() noexcept { return 0; } 
881 
882 static constexpr char32_t 
883 round_error() noexcept { return 0; } 
884 
885 static constexpr int min_exponent = 0; 
886 static constexpr int min_exponent10 = 0; 
887 static constexpr int max_exponent = 0; 
888 static constexpr int max_exponent10 = 0; 
889 
890 static constexpr bool has_infinity = false; 
891 static constexpr bool has_quiet_NaN = false; 
892 static constexpr bool has_signaling_NaN = false; 
893 static constexpr float_denorm_style has_denorm = denorm_absent; 
894 static constexpr bool has_denorm_loss = false; 
895 
896 static constexpr char32_t 
897 infinity() noexcept { return char32_t(); } 
898 
899 static constexpr char32_t 
900 quiet_NaN() noexcept { return char32_t(); } 
901 
902 static constexpr char32_t 
903 signaling_NaN() noexcept { return char32_t(); } 
904 
905 static constexpr char32_t 
906 denorm_min() noexcept { return char32_t(); } 
907 
908 static constexpr bool is_iec559 = false; 
909 static constexpr bool is_bounded = true; 
910 static constexpr bool is_modulo = !is_signed; 
911 
912 static constexpr bool traps = __glibcxx_integral_traps; 
913 static constexpr bool tinyness_before = false; 
914 static constexpr float_round_style round_style = round_toward_zero; 
915 }; 
916#endif 
917 
918 /// numeric_limits<short> specialization. 
919 template<> 
920 struct numeric_limits<short> 
921 { 
922 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 
923 
924 static _GLIBCXX_CONSTEXPR short 
925 min() _GLIBCXX_USE_NOEXCEPT { return -__SHRT_MAX__ - 1; } 
926 
927 static _GLIBCXX_CONSTEXPR short 
928 max() _GLIBCXX_USE_NOEXCEPT { return __SHRT_MAX__; } 
929 
930#if __cplusplus >= 201103L 
931 static constexpr short 
932 lowest() noexcept { return min(); } 
933#endif 
934 
935 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (short); 
936 static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (short); 
937#if __cplusplus >= 201103L 
938 static constexpr int max_digits10 = 0; 
939#endif 
940 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 
941 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 
942 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 
943 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 
944 
945 static _GLIBCXX_CONSTEXPR short 
946 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 
947 
948 static _GLIBCXX_CONSTEXPR short 
949 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 
950 
951 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 
952 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 
953 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 
954 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 
955 
956 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 
957 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 
958 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 
959 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 
960 = denorm_absent; 
961 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 
962 
963 static _GLIBCXX_CONSTEXPR short 
964 infinity() _GLIBCXX_USE_NOEXCEPT { return short(); } 
965 
966 static _GLIBCXX_CONSTEXPR short 
967 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return short(); } 
968 
969 static _GLIBCXX_CONSTEXPR short 
970 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return short(); } 
971 
972 static _GLIBCXX_CONSTEXPR short 
973 denorm_min() _GLIBCXX_USE_NOEXCEPT { return short(); } 
974 
975 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 
976 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 
977 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 
978 
979 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 
980 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 
981 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 
982 = round_toward_zero; 
983 }; 
984 
985 /// numeric_limits<unsigned short> specialization. 
986 template<> 
987 struct numeric_limits<unsigned short> 
988 { 
989 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 
990 
991 static _GLIBCXX_CONSTEXPR unsigned short 
992 min() _GLIBCXX_USE_NOEXCEPT { return 0; } 
993 
994 static _GLIBCXX_CONSTEXPR unsigned short 
995 max() _GLIBCXX_USE_NOEXCEPT { return __SHRT_MAX__ * 2U + 1; } 
996 
997#if __cplusplus >= 201103L 
998 static constexpr unsigned short 
999 lowest() noexcept { return min(); } 
1000#endif 
1001 
1002 static _GLIBCXX_USE_CONSTEXPR int digits 
1003 = __glibcxx_digits (unsigned short); 
1004 static _GLIBCXX_USE_CONSTEXPR int digits10 
1005 = __glibcxx_digits10 (unsigned short); 
1006#if __cplusplus >= 201103L 
1007 static constexpr int max_digits10 = 0; 
1008#endif 
1009 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 
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 unsigned short 
1015 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 
1016 
1017 static _GLIBCXX_CONSTEXPR unsigned short 
1018 round_error() _GLIBCXX_USE_NOEXCEPT { 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 unsigned short 
1033 infinity() _GLIBCXX_USE_NOEXCEPT 
1034 { return static_cast<unsigned short>(0); } 
1035 
1036 static _GLIBCXX_CONSTEXPR unsigned short 
1037 quiet_NaN() _GLIBCXX_USE_NOEXCEPT 
1038 { return static_cast<unsigned short>(0); } 
1039 
1040 static _GLIBCXX_CONSTEXPR unsigned short 
1041 signaling_NaN() _GLIBCXX_USE_NOEXCEPT 
1042 { return static_cast<unsigned short>(0); } 
1043 
1044 static _GLIBCXX_CONSTEXPR unsigned short 
1045 denorm_min() _GLIBCXX_USE_NOEXCEPT 
1046 { return static_cast<unsigned short>(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 = true; 
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<int> specialization. 
1059 template<> 
1060 struct numeric_limits<int> 
1061 { 
1062 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 
1063 
1064 static _GLIBCXX_CONSTEXPR int 
1065 min() _GLIBCXX_USE_NOEXCEPT { return -__INT_MAX__ - 1; } 
1066 
1067 static _GLIBCXX_CONSTEXPR int 
1068 max() _GLIBCXX_USE_NOEXCEPT { return __INT_MAX__; } 
1069 
1070#if __cplusplus >= 201103L 
1071 static constexpr int 
1072 lowest() noexcept { return min(); } 
1073#endif 
1074 
1075 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (int); 
1076 static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (int); 
1077#if __cplusplus >= 201103L 
1078 static constexpr int max_digits10 = 0; 
1079#endif 
1080 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 
1081 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 
1082 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 
1083 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 
1084 
1085 static _GLIBCXX_CONSTEXPR int 
1086 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 
1087 
1088 static _GLIBCXX_CONSTEXPR int 
1089 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 
1090 
1091 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 
1092 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 
1093 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 
1094 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 
1095 
1096 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 
1097 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 
1098 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 
1099 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 
1100 = denorm_absent; 
1101 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 
1102 
1103 static _GLIBCXX_CONSTEXPR int 
1104 infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); } 
1105 
1106 static _GLIBCXX_CONSTEXPR int 
1107 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); } 
1108 
1109 static _GLIBCXX_CONSTEXPR int 
1110 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); } 
1111 
1112 static _GLIBCXX_CONSTEXPR int 
1113 denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); } 
1114 
1115 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 
1116 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 
1117 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 
1118 
1119 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 
1120 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 
1121 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 
1122 = round_toward_zero; 
1123 }; 
1124 
1125 /// numeric_limits<unsigned int> specialization. 
1126 template<> 
1127 struct numeric_limits<unsigned int> 
1128 { 
1129 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 
1130 
1131 static _GLIBCXX_CONSTEXPR unsigned int 
1132 min() _GLIBCXX_USE_NOEXCEPT { return 0; } 
1133 
1134 static _GLIBCXX_CONSTEXPR unsigned int 
1135 max() _GLIBCXX_USE_NOEXCEPT { return __INT_MAX__ * 2U + 1; } 
1136 
1137#if __cplusplus >= 201103L 
1138 static constexpr unsigned int 
1139 lowest() noexcept { return min(); } 
1140#endif 
1141 
1142 static _GLIBCXX_USE_CONSTEXPR int digits 
1143 = __glibcxx_digits (unsigned int); 
1144 static _GLIBCXX_USE_CONSTEXPR int digits10 
1145 = __glibcxx_digits10 (unsigned int); 
1146#if __cplusplus >= 201103L 
1147 static constexpr int max_digits10 = 0; 
1148#endif 
1149 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 
1150 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 
1151 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 
1152 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 
1153 
1154 static _GLIBCXX_CONSTEXPR unsigned int 
1155 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 
1156 
1157 static _GLIBCXX_CONSTEXPR unsigned int 
1158 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 
1159 
1160 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 
1161 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 
1162 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 
1163 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 
1164 
1165 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 
1166 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 
1167 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 
1168 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 
1169 = denorm_absent; 
1170 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 
1171 
1172 static _GLIBCXX_CONSTEXPR unsigned int 
1173 infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<unsigned int>(0); } 
1174 
1175 static _GLIBCXX_CONSTEXPR unsigned int 
1176 quiet_NaN() _GLIBCXX_USE_NOEXCEPT 
1177 { return static_cast<unsigned int>(0); } 
1178 
1179 static _GLIBCXX_CONSTEXPR unsigned int 
1180 signaling_NaN() _GLIBCXX_USE_NOEXCEPT 
1181 { return static_cast<unsigned int>(0); } 
1182 
1183 static _GLIBCXX_CONSTEXPR unsigned int 
1184 denorm_min() _GLIBCXX_USE_NOEXCEPT 
1185 { return static_cast<unsigned int>(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 = true; 
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<long> specialization. 
1198 template<> 
1199 struct numeric_limits<long> 
1200 { 
1201 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 
1202 
1203 static _GLIBCXX_CONSTEXPR long 
1204 min() _GLIBCXX_USE_NOEXCEPT { return -__LONG_MAX__ - 1; } 
1205 
1206 static _GLIBCXX_CONSTEXPR long 
1207 max() _GLIBCXX_USE_NOEXCEPT { return __LONG_MAX__; } 
1208 
1209#if __cplusplus >= 201103L 
1210 static constexpr long 
1211 lowest() noexcept { return min(); } 
1212#endif 
1213 
1214 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (long); 
1215 static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (long); 
1216#if __cplusplus >= 201103L 
1217 static constexpr int max_digits10 = 0; 
1218#endif 
1219 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 
1220 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 
1221 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 
1222 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 
1223 
1224 static _GLIBCXX_CONSTEXPR long 
1225 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 
1226 
1227 static _GLIBCXX_CONSTEXPR long 
1228 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 
1229 
1230 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 
1231 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 
1232 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 
1233 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 
1234 
1235 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 
1236 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 
1237 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 
1238 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 
1239 = denorm_absent; 
1240 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 
1241 
1242 static _GLIBCXX_CONSTEXPR long 
1243 infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); } 
1244 
1245 static _GLIBCXX_CONSTEXPR long 
1246 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); } 
1247 
1248 static _GLIBCXX_CONSTEXPR long 
1249 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); } 
1250 
1251 static _GLIBCXX_CONSTEXPR long 
1252 denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); } 
1253 
1254 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 
1255 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 
1256 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 
1257 
1258 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 
1259 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 
1260 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 
1261 = round_toward_zero; 
1262 }; 
1263 
1264 /// numeric_limits<unsigned long> specialization. 
1265 template<> 
1266 struct numeric_limits<unsigned long> 
1267 { 
1268 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 
1269 
1270 static _GLIBCXX_CONSTEXPR unsigned long 
1271 min() _GLIBCXX_USE_NOEXCEPT { return 0; } 
1272 
1273 static _GLIBCXX_CONSTEXPR unsigned long 
1274 max() _GLIBCXX_USE_NOEXCEPT { return __LONG_MAX__ * 2UL + 1; } 
1275 
1276#if __cplusplus >= 201103L 
1277 static constexpr unsigned long 
1278 lowest() noexcept { return min(); } 
1279#endif 
1280 
1281 static _GLIBCXX_USE_CONSTEXPR int digits 
1282 = __glibcxx_digits (unsigned long); 
1283 static _GLIBCXX_USE_CONSTEXPR int digits10 
1284 = __glibcxx_digits10 (unsigned long); 
1285#if __cplusplus >= 201103L 
1286 static constexpr int max_digits10 = 0; 
1287#endif 
1288 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 
1289 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 
1290 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 
1291 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 
1292 
1293 static _GLIBCXX_CONSTEXPR unsigned long 
1294 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 
1295 
1296 static _GLIBCXX_CONSTEXPR unsigned long 
1297 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 
1298 
1299 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 
1300 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 
1301 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 
1302 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 
1303 
1304 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 
1305 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 
1306 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 
1307 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 
1308 = denorm_absent; 
1309 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 
1310 
1311 static _GLIBCXX_CONSTEXPR unsigned long 
1312 infinity() _GLIBCXX_USE_NOEXCEPT 
1313 { return static_cast<unsigned long>(0); } 
1314 
1315 static _GLIBCXX_CONSTEXPR unsigned long 
1316 quiet_NaN() _GLIBCXX_USE_NOEXCEPT 
1317 { return static_cast<unsigned long>(0); } 
1318 
1319 static _GLIBCXX_CONSTEXPR unsigned long 
1320 signaling_NaN() _GLIBCXX_USE_NOEXCEPT 
1321 { return static_cast<unsigned long>(0); } 
1322 
1323 static _GLIBCXX_CONSTEXPR unsigned long 
1324 denorm_min() _GLIBCXX_USE_NOEXCEPT 
1325 { return static_cast<unsigned long>(0); } 
1326 
1327 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 
1328 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 
1329 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 
1330 
1331 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 
1332 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 
1333 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 
1334 = round_toward_zero; 
1335 }; 
1336 
1337 /// numeric_limits<long long> specialization. 
1338 template<> 
1339 struct numeric_limits<long long> 
1340 { 
1341 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 
1342 
1343 static _GLIBCXX_CONSTEXPR long long 
1344 min() _GLIBCXX_USE_NOEXCEPT { return -__LONG_LONG_MAX__ - 1; } 
1345 
1346 static _GLIBCXX_CONSTEXPR long long 
1347 max() _GLIBCXX_USE_NOEXCEPT { return __LONG_LONG_MAX__; } 
1348 
1349#if __cplusplus >= 201103L 
1350 static constexpr long long 
1351 lowest() noexcept { return min(); } 
1352#endif 
1353 
1354 static _GLIBCXX_USE_CONSTEXPR int digits 
1355 = __glibcxx_digits (long long); 
1356 static _GLIBCXX_USE_CONSTEXPR int digits10 
1357 = __glibcxx_digits10 (long long); 
1358#if __cplusplus >= 201103L 
1359 static constexpr int max_digits10 = 0; 
1360#endif 
1361 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 
1362 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 
1363 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 
1364 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 
1365 
1366 static _GLIBCXX_CONSTEXPR long long 
1367 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 
1368 
1369 static _GLIBCXX_CONSTEXPR long long 
1370 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 
1371 
1372 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 
1373 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 
1374 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 
1375 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 
1376 
1377 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 
1378 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 
1379 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 
1380 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 
1381 = denorm_absent; 
1382 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 
1383 
1384 static _GLIBCXX_CONSTEXPR long long 
1385 infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); } 
1386 
1387 static _GLIBCXX_CONSTEXPR long long 
1388 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); } 
1389 
1390 static _GLIBCXX_CONSTEXPR long long 
1391 signaling_NaN() _GLIBCXX_USE_NOEXCEPT 
1392 { return static_cast<long long>(0); } 
1393 
1394 static _GLIBCXX_CONSTEXPR long long 
1395 denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); } 
1396 
1397 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 
1398 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 
1399 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 
1400 
1401 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 
1402 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 
1403 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 
1404 = round_toward_zero; 
1405 }; 
1406 
1407 /// numeric_limits<unsigned long long> specialization. 
1408 template<> 
1409 struct numeric_limits<unsigned long long> 
1410 { 
1411 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 
1412 
1413 static _GLIBCXX_CONSTEXPR unsigned long long 
1414 min() _GLIBCXX_USE_NOEXCEPT { return 0; } 
1415 
1416 static _GLIBCXX_CONSTEXPR unsigned long long 
1417 max() _GLIBCXX_USE_NOEXCEPT { return __LONG_LONG_MAX__ * 2ULL + 1; } 
1418 
1419#if __cplusplus >= 201103L 
1420 static constexpr unsigned long long 
1421 lowest() noexcept { return min(); } 
1422#endif 
1423 
1424 static _GLIBCXX_USE_CONSTEXPR int digits 
1425 = __glibcxx_digits (unsigned long long); 
1426 static _GLIBCXX_USE_CONSTEXPR int digits10 
1427 = __glibcxx_digits10 (unsigned long long); 
1428#if __cplusplus >= 201103L 
1429 static constexpr int max_digits10 = 0; 
1430#endif 
1431 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 
1432 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 
1433 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 
1434 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 
1435 
1436 static _GLIBCXX_CONSTEXPR unsigned long long 
1437 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 
1438 
1439 static _GLIBCXX_CONSTEXPR unsigned long long 
1440 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 
1441 
1442 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 
1443 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 
1444 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 
1445 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 
1446 
1447 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 
1448 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 
1449 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 
1450 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 
1451 = denorm_absent; 
1452 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 
1453 
1454 static _GLIBCXX_CONSTEXPR unsigned long long 
1455 infinity() _GLIBCXX_USE_NOEXCEPT 
1456 { return static_cast<unsigned long long>(0); } 
1457 
1458 static _GLIBCXX_CONSTEXPR unsigned long long 
1459 quiet_NaN() _GLIBCXX_USE_NOEXCEPT 
1460 { return static_cast<unsigned long long>(0); } 
1461 
1462 static _GLIBCXX_CONSTEXPR unsigned long long 
1463 signaling_NaN() _GLIBCXX_USE_NOEXCEPT 
1464 { return static_cast<unsigned long long>(0); } 
1465 
1466 static _GLIBCXX_CONSTEXPR unsigned long long 
1467 denorm_min() _GLIBCXX_USE_NOEXCEPT 
1468 { return static_cast<unsigned long long>(0); } 
1469 
1470 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 
1471 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 
1472 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 
1473 
1474 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 
1475 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 
1476 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 
1477 = round_toward_zero; 
1478 }; 
1479 
1480#if !defined(__STRICT_ANSI__) 
1481 
1482#define __INT_N(TYPE, BITSIZE, EXT, UEXT) \ 
1483 template<> \ 
1484 struct numeric_limits<TYPE> \ 
1485 { \ 
1486 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; \ 
1487 \ 
1488 static _GLIBCXX_CONSTEXPR TYPE \ 
1489 min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min_b (TYPE, BITSIZE); } \ 
1490 \ 
1491 static _GLIBCXX_CONSTEXPR TYPE \ 
1492 max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max_b (TYPE, BITSIZE); } \ 
1493 \ 
1494 static _GLIBCXX_USE_CONSTEXPR int digits \ 
1495 = BITSIZE - 1; \ 
1496 static _GLIBCXX_USE_CONSTEXPR int digits10 \ 
1497 = (BITSIZE - 1) * 643L / 2136; \ 
1498 \ 
1499 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; \ 
1500 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; \ 
1501 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; \ 
1502 static _GLIBCXX_USE_CONSTEXPR int radix = 2; \ 
1503 \ 
1504 static _GLIBCXX_CONSTEXPR TYPE \ 
1505 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } \ 
1506 \ 
1507 static _GLIBCXX_CONSTEXPR TYPE \ 
1508 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } \ 
1509 \ 
1510 EXT \ 
1511 \ 
1512 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; \ 
1513 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; \ 
1514 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; \ 
1515 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; \ 
1516 \ 
1517 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; \ 
1518 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; \ 
1519 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; \ 
1520 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm \ 
1521 = denorm_absent; \ 
1522 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; \ 
1523 \ 
1524 static _GLIBCXX_CONSTEXPR TYPE \ 
1525 infinity() _GLIBCXX_USE_NOEXCEPT \ 
1526 { return static_cast<TYPE>(0); } \ 
1527 \ 
1528 static _GLIBCXX_CONSTEXPR TYPE \ 
1529 quiet_NaN() _GLIBCXX_USE_NOEXCEPT \ 
1530 { return static_cast<TYPE>(0); } \ 
1531 \ 
1532 static _GLIBCXX_CONSTEXPR TYPE \ 
1533 signaling_NaN() _GLIBCXX_USE_NOEXCEPT \ 
1534 { return static_cast<TYPE>(0); } \ 
1535 \ 
1536 static _GLIBCXX_CONSTEXPR TYPE \ 
1537 denorm_min() _GLIBCXX_USE_NOEXCEPT \ 
1538 { return static_cast<TYPE>(0); } \ 
1539 \ 
1540 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; \ 
1541 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; \ 
1542 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; \ 
1543 \ 
1544 static _GLIBCXX_USE_CONSTEXPR bool traps \ 
1545 = __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 template<> \ 
1552 struct numeric_limits<unsigned TYPE> \ 
1553 { \ 
1554 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; \ 
1555 \ 
1556 static _GLIBCXX_CONSTEXPR unsigned TYPE \ 
1557 min() _GLIBCXX_USE_NOEXCEPT { return 0; } \ 
1558 \ 
1559 static _GLIBCXX_CONSTEXPR unsigned TYPE \ 
1560 max() _GLIBCXX_USE_NOEXCEPT \ 
1561 { return __glibcxx_max_b (unsigned TYPE, BITSIZE); } \ 
1562 \ 
1563 UEXT \ 
1564 \ 
1565 static _GLIBCXX_USE_CONSTEXPR int digits \ 
1566 = BITSIZE; \ 
1567 static _GLIBCXX_USE_CONSTEXPR int digits10 \ 
1568 = BITSIZE * 643L / 2136; \ 
1569 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; \ 
1570 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; \ 
1571 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; \ 
1572 static _GLIBCXX_USE_CONSTEXPR int radix = 2; \ 
1573 \ 
1574 static _GLIBCXX_CONSTEXPR unsigned TYPE \ 
1575 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } \ 
1576 \ 
1577 static _GLIBCXX_CONSTEXPR unsigned TYPE \ 
1578 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } \ 
1579 \ 
1580 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; \ 
1581 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; \ 
1582 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; \ 
1583 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; \ 
1584 \ 
1585 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; \ 
1586 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; \ 
1587 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; \ 
1588 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm \ 
1589 = denorm_absent; \ 
1590 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; \ 
1591 \ 
1592 static _GLIBCXX_CONSTEXPR unsigned TYPE \ 
1593 infinity() _GLIBCXX_USE_NOEXCEPT \ 
1594 { return static_cast<unsigned TYPE>(0); } \ 
1595 \ 
1596 static _GLIBCXX_CONSTEXPR unsigned TYPE \ 
1597 quiet_NaN() _GLIBCXX_USE_NOEXCEPT \ 
1598 { return static_cast<unsigned TYPE>(0); } \ 
1599 \ 
1600 static _GLIBCXX_CONSTEXPR unsigned TYPE \ 
1601 signaling_NaN() _GLIBCXX_USE_NOEXCEPT \ 
1602 { return static_cast<unsigned TYPE>(0); } \ 
1603 \ 
1604 static _GLIBCXX_CONSTEXPR unsigned TYPE \ 
1605 denorm_min() _GLIBCXX_USE_NOEXCEPT \ 
1606 { return static_cast<unsigned TYPE>(0); } \ 
1607 \ 
1608 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; \ 
1609 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; \ 
1610 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; \ 
1611 \ 
1612 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; \ 
1613 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; \ 
1614 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style \ 
1615 = round_toward_zero; \ 
1616 }; 
1617 
1618#if __cplusplus >= 201103L 
1619 
1620#define __INT_N_201103(TYPE) \ 
1621 static constexpr TYPE \ 
1622 lowest() noexcept { return min(); } \ 
1623 static constexpr int max_digits10 = 0; 
1624 
1625#define __INT_N_U201103(TYPE) \ 
1626 static constexpr unsigned TYPE \ 
1627 lowest() noexcept { return min(); } \ 
1628 static constexpr int max_digits10 = 0; 
1629 
1630#else 
1631#define __INT_N_201103(TYPE) 
1632#define __INT_N_U201103(TYPE) 
1633#endif 
1634 
1635#ifdef __GLIBCXX_TYPE_INT_N_0 
1636 __INT_N(__GLIBCXX_TYPE_INT_N_0, __GLIBCXX_BITSIZE_INT_N_0, 
1637 __INT_N_201103 (__GLIBCXX_TYPE_INT_N_0), __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_0)) 
1638#endif 
1639#ifdef __GLIBCXX_TYPE_INT_N_1 
1640 __INT_N (__GLIBCXX_TYPE_INT_N_1, __GLIBCXX_BITSIZE_INT_N_1, 
1641 __INT_N_201103 (__GLIBCXX_TYPE_INT_N_1), __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_1)) 
1642#endif 
1643#ifdef __GLIBCXX_TYPE_INT_N_2 
1644 __INT_N (__GLIBCXX_TYPE_INT_N_2, __GLIBCXX_BITSIZE_INT_N_2, 
1645 __INT_N_201103 (__GLIBCXX_TYPE_INT_N_2), __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_2)) 
1646#endif 
1647#ifdef __GLIBCXX_TYPE_INT_N_3 
1648 __INT_N (__GLIBCXX_TYPE_INT_N_3, __GLIBCXX_BITSIZE_INT_N_3, 
1649 __INT_N_201103 (__GLIBCXX_TYPE_INT_N_3), __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_3)) 
1650#endif 
1651 
1652#undef __INT_N 
1653#undef __INT_N_201103 
1654#undef __INT_N_U201103 
1655 
1656#endif 
1657 
1658 /// numeric_limits<float> specialization. 
1659 template<> 
1660 struct numeric_limits<float> 
1661 { 
1662 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 
1663 
1664 static _GLIBCXX_CONSTEXPR float 
1665 min() _GLIBCXX_USE_NOEXCEPT { return __FLT_MIN__; } 
1666 
1667 static _GLIBCXX_CONSTEXPR float 
1668 max() _GLIBCXX_USE_NOEXCEPT { return __FLT_MAX__; } 
1669 
1670#if __cplusplus >= 201103L 
1671 static constexpr float 
1672 lowest() noexcept { return -__FLT_MAX__; } 
1673#endif 
1674 
1675 static _GLIBCXX_USE_CONSTEXPR int digits = __FLT_MANT_DIG__; 
1676 static _GLIBCXX_USE_CONSTEXPR int digits10 = __FLT_DIG__; 
1677#if __cplusplus >= 201103L 
1678 static constexpr int max_digits10 
1679 = __glibcxx_max_digits10 (__FLT_MANT_DIG__); 
1680#endif 
1681 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 
1682 static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; 
1683 static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; 
1684 static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; 
1685 
1686 static _GLIBCXX_CONSTEXPR float 
1687 epsilon() _GLIBCXX_USE_NOEXCEPT { return __FLT_EPSILON__; } 
1688 
1689 static _GLIBCXX_CONSTEXPR float 
1690 round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5F; } 
1691 
1692 static _GLIBCXX_USE_CONSTEXPR int min_exponent = __FLT_MIN_EXP__; 
1693 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __FLT_MIN_10_EXP__; 
1694 static _GLIBCXX_USE_CONSTEXPR int max_exponent = __FLT_MAX_EXP__; 
1695 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __FLT_MAX_10_EXP__; 
1696 
1697 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __FLT_HAS_INFINITY__; 
1698 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __FLT_HAS_QUIET_NAN__; 
1699 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN; 
1700 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 
1701 = bool(__FLT_HAS_DENORM__) ? denorm_present : denorm_absent; 
1702 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss 
1703 = __glibcxx_float_has_denorm_loss; 
1704 
1705 static _GLIBCXX_CONSTEXPR float 
1706 infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_valf(); } 
1707 
1708 static _GLIBCXX_CONSTEXPR float 
1709 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nanf(""); } 
1710 
1711 static _GLIBCXX_CONSTEXPR float 
1712 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nansf(""); } 
1713 
1714 static _GLIBCXX_CONSTEXPR float 
1715 denorm_min() _GLIBCXX_USE_NOEXCEPT { return __FLT_DENORM_MIN__; } 
1716 
1717 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 
1718 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; 
1719 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 
1720 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 
1721 
1722 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_float_traps; 
1723 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before 
1724 = __glibcxx_float_tinyness_before; 
1725 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 
1726 = round_to_nearest; 
1727 }; 
1728 
1729#undef __glibcxx_float_has_denorm_loss 
1730#undef __glibcxx_float_traps 
1731#undef __glibcxx_float_tinyness_before 
1732 
1733 /// numeric_limits<double> specialization. 
1734 template<> 
1735 struct numeric_limits<double> 
1736 { 
1737 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 
1738 
1739 static _GLIBCXX_CONSTEXPR double 
1740 min() _GLIBCXX_USE_NOEXCEPT { return __DBL_MIN__; } 
1741 
1742 static _GLIBCXX_CONSTEXPR double 
1743 max() _GLIBCXX_USE_NOEXCEPT { return __DBL_MAX__; } 
1744 
1745#if __cplusplus >= 201103L 
1746 static constexpr double 
1747 lowest() noexcept { return -__DBL_MAX__; } 
1748#endif 
1749 
1750 static _GLIBCXX_USE_CONSTEXPR int digits = __DBL_MANT_DIG__; 
1751 static _GLIBCXX_USE_CONSTEXPR int digits10 = __DBL_DIG__; 
1752#if __cplusplus >= 201103L 
1753 static constexpr int max_digits10 
1754 = __glibcxx_max_digits10 (__DBL_MANT_DIG__); 
1755#endif 
1756 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 
1757 static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; 
1758 static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; 
1759 static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; 
1760 
1761 static _GLIBCXX_CONSTEXPR double 
1762 epsilon() _GLIBCXX_USE_NOEXCEPT { return __DBL_EPSILON__; } 
1763 
1764 static _GLIBCXX_CONSTEXPR double 
1765 round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5; } 
1766 
1767 static _GLIBCXX_USE_CONSTEXPR int min_exponent = __DBL_MIN_EXP__; 
1768 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __DBL_MIN_10_EXP__; 
1769 static _GLIBCXX_USE_CONSTEXPR int max_exponent = __DBL_MAX_EXP__; 
1770 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __DBL_MAX_10_EXP__; 
1771 
1772 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __DBL_HAS_INFINITY__; 
1773 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __DBL_HAS_QUIET_NAN__; 
1774 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN; 
1775 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 
1776 = bool(__DBL_HAS_DENORM__) ? denorm_present : denorm_absent; 
1777 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss 
1778 = __glibcxx_double_has_denorm_loss; 
1779 
1780 static _GLIBCXX_CONSTEXPR double 
1781 infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_val(); } 
1782 
1783 static _GLIBCXX_CONSTEXPR double 
1784 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nan(""); } 
1785 
1786 static _GLIBCXX_CONSTEXPR double 
1787 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nans(""); } 
1788 
1789 static _GLIBCXX_CONSTEXPR double 
1790 denorm_min() _GLIBCXX_USE_NOEXCEPT { return __DBL_DENORM_MIN__; } 
1791 
1792 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 
1793 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; 
1794 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 
1795 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 
1796 
1797 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_double_traps; 
1798 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before 
1799 = __glibcxx_double_tinyness_before; 
1800 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 
1801 = round_to_nearest; 
1802 }; 
1803 
1804#undef __glibcxx_double_has_denorm_loss 
1805#undef __glibcxx_double_traps 
1806#undef __glibcxx_double_tinyness_before 
1807 
1808 /// numeric_limits<long double> specialization. 
1809 template<> 
1810 struct numeric_limits<long double> 
1811 { 
1812 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 
1813 
1814 static _GLIBCXX_CONSTEXPR long double 
1815 min() _GLIBCXX_USE_NOEXCEPT { return __LDBL_MIN__; } 
1816 
1817 static _GLIBCXX_CONSTEXPR long double 
1818 max() _GLIBCXX_USE_NOEXCEPT { return __LDBL_MAX__; } 
1819 
1820#if __cplusplus >= 201103L 
1821 static constexpr long double 
1822 lowest() noexcept { return -__LDBL_MAX__; } 
1823#endif 
1824 
1825 static _GLIBCXX_USE_CONSTEXPR int digits = __LDBL_MANT_DIG__; 
1826 static _GLIBCXX_USE_CONSTEXPR int digits10 = __LDBL_DIG__; 
1827#if __cplusplus >= 201103L 
1828 static _GLIBCXX_USE_CONSTEXPR int max_digits10 
1829 = __glibcxx_max_digits10 (__LDBL_MANT_DIG__); 
1830#endif 
1831 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 
1832 static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; 
1833 static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; 
1834 static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; 
1835 
1836 static _GLIBCXX_CONSTEXPR long double 
1837 epsilon() _GLIBCXX_USE_NOEXCEPT { return __LDBL_EPSILON__; } 
1838 
1839 static _GLIBCXX_CONSTEXPR long double 
1840 round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5L; } 
1841 
1842 static _GLIBCXX_USE_CONSTEXPR int min_exponent = __LDBL_MIN_EXP__; 
1843 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __LDBL_MIN_10_EXP__; 
1844 static _GLIBCXX_USE_CONSTEXPR int max_exponent = __LDBL_MAX_EXP__; 
1845 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __LDBL_MAX_10_EXP__; 
1846 
1847 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __LDBL_HAS_INFINITY__; 
1848 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __LDBL_HAS_QUIET_NAN__; 
1849 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN; 
1850 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 
1851 = bool(__LDBL_HAS_DENORM__) ? denorm_present : denorm_absent; 
1852 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss 
1853 = __glibcxx_long_double_has_denorm_loss; 
1854 
1855 static _GLIBCXX_CONSTEXPR long double 
1856 infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_vall(); } 
1857 
1858 static _GLIBCXX_CONSTEXPR long double 
1859 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nanl(""); } 
1860 
1861 static _GLIBCXX_CONSTEXPR long double 
1862 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nansl(""); } 
1863 
1864 static _GLIBCXX_CONSTEXPR long double 
1865 denorm_min() _GLIBCXX_USE_NOEXCEPT { return __LDBL_DENORM_MIN__; } 
1866 
1867 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 
1868 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; 
1869 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 
1870 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 
1871 
1872 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_long_double_traps; 
1873 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = 
1874 __glibcxx_long_double_tinyness_before; 
1875 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = 
1876 round_to_nearest; 
1877 }; 
1878 
1879#undef __glibcxx_long_double_has_denorm_loss 
1880#undef __glibcxx_long_double_traps 
1881#undef __glibcxx_long_double_tinyness_before 
1882 
1883_GLIBCXX_END_NAMESPACE_VERSION 
1884} // namespace 
1885 
1886#undef __glibcxx_signed 
1887#undef __glibcxx_min 
1888#undef __glibcxx_max 
1889#undef __glibcxx_digits 
1890#undef __glibcxx_digits10 
1891#undef __glibcxx_max_digits10 
1892 
1893#endif // _GLIBCXX_NUMERIC_LIMITS 
1894