Branch data 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 : 0 : 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 : 204268 : min() _GLIBCXX_USE_NOEXCEPT { return -__INT_MAX__ - 1; }
988 : :
989 : : static _GLIBCXX_CONSTEXPR int
990 : 204932 : 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 : 20 : min() _GLIBCXX_USE_NOEXCEPT { return 0; }
1055 : :
1056 : : static _GLIBCXX_CONSTEXPR unsigned int
1057 : 40 : 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 : 0 : quiet_NaN() _GLIBCXX_USE_NOEXCEPT
1099 : 0 : { 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 : 78 : min() _GLIBCXX_USE_NOEXCEPT { return -__LONG_MAX__ - 1; }
1127 : :
1128 : : static _GLIBCXX_CONSTEXPR long
1129 : 1886 : 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 : 73320 : 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 : 29701040 : 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 : 730 : min() _GLIBCXX_USE_NOEXCEPT { return __DBL_MIN__; }
1634 : :
1635 : : static _GLIBCXX_CONSTEXPR double
1636 : 517348 : 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 : 42280 : epsilon() _GLIBCXX_USE_NOEXCEPT { return __DBL_EPSILON__; }
1656 : :
1657 : : static _GLIBCXX_CONSTEXPR double
1658 : 16 : 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 : 83684 : infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_val(); }
1675 : :
1676 : : static _GLIBCXX_CONSTEXPR double
1677 : 714 : quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nan(""); }
1678 : :
1679 : : static _GLIBCXX_CONSTEXPR double
1680 : 16 : signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nans(""); }
1681 : :
1682 : : static _GLIBCXX_CONSTEXPR double
1683 : 20 : 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 : 2716 : min() _GLIBCXX_USE_NOEXCEPT { return __LDBL_MIN__; }
1709 : :
1710 : : static _GLIBCXX_CONSTEXPR long double
1711 : 348866 : 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 : 608798 : 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 : 0 : infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_vall(); }
1750 : :
1751 : : static _GLIBCXX_CONSTEXPR long double
1752 : 0 : 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
|