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