Context Navigation

limits

Last change on this file was 1166, checked in by rossy, 3 years ago
Daodan: Replace MinGW build env with an up-to-date MSYS2 env
File size: 70.0 KB

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

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: Daodan/MSYS2/mingw32/include/c++/11.2.0/limits

Download in other formats: