← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to system/include/libcxx/limits

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-02 13:11:51 UTC
  • Revision ID: package-import@ubuntu.com-20130502131151-q8dvteqr1ef2x7xz
Tags: upstream-1.4.1~20130504~adb56cb
Import upstream version 1.4.1~20130504~adb56cb

Show diffs side-by-side

added added

removed removed

Lines of Context:
system/include/libcxx/limits
 
1
// -*- C++ -*-
 
2
//===---------------------------- limits ----------------------------------===//
 
3
//
 
4
//                     The LLVM Compiler Infrastructure
 
5
//
 
6
// This file is dual licensed under the MIT and the University of Illinois Open
 
7
// Source Licenses. See LICENSE.TXT for details.
 
8
//
 
9
//===----------------------------------------------------------------------===//
 
10
 
 
11
#ifndef _LIBCPP_LIMITS
 
12
#define _LIBCPP_LIMITS
 
13
 
 
14
/*
 
15
    limits synopsis
 
16
 
 
17
namespace std
 
18
{
 
19
 
 
20
template<class T>
 
21
class numeric_limits
 
22
{
 
23
public:
 
24
    static constexpr bool is_specialized = false;
 
25
    static constexpr T min() noexcept;
 
26
    static constexpr T max() noexcept;
 
27
    static constexpr T lowest() noexcept;
 
28
 
 
29
    static constexpr int  digits = 0;
 
30
    static constexpr int  digits10 = 0;
 
31
    static constexpr int  max_digits10 = 0;
 
32
    static constexpr bool is_signed = false;
 
33
    static constexpr bool is_integer = false;
 
34
    static constexpr bool is_exact = false;
 
35
    static constexpr int  radix = 0;
 
36
    static constexpr T epsilon() noexcept;
 
37
    static constexpr T round_error() noexcept;
 
38
 
 
39
    static constexpr int  min_exponent = 0;
 
40
    static constexpr int  min_exponent10 = 0;
 
41
    static constexpr int  max_exponent = 0;
 
42
    static constexpr int  max_exponent10 = 0;
 
43
 
 
44
    static constexpr bool has_infinity = false;
 
45
    static constexpr bool has_quiet_NaN = false;
 
46
    static constexpr bool has_signaling_NaN = false;
 
47
    static constexpr float_denorm_style has_denorm = denorm_absent;
 
48
    static constexpr bool has_denorm_loss = false;
 
49
    static constexpr T infinity() noexcept;
 
50
    static constexpr T quiet_NaN() noexcept;
 
51
    static constexpr T signaling_NaN() noexcept;
 
52
    static constexpr T denorm_min() noexcept;
 
53
 
 
54
    static constexpr bool is_iec559 = false;
 
55
    static constexpr bool is_bounded = false;
 
56
    static constexpr bool is_modulo = false;
 
57
 
 
58
    static constexpr bool traps = false;
 
59
    static constexpr bool tinyness_before = false;
 
60
    static constexpr float_round_style round_style = round_toward_zero;
 
61
};
 
62
 
 
63
enum float_round_style
 
64
{
 
65
    round_indeterminate       = -1,
 
66
    round_toward_zero         =  0,
 
67
    round_to_nearest          =  1,
 
68
    round_toward_infinity     =  2,
 
69
    round_toward_neg_infinity =  3
 
70
};
 
71
 
 
72
enum float_denorm_style
 
73
{
 
74
    denorm_indeterminate = -1,
 
75
    denorm_absent = 0,
 
76
    denorm_present = 1
 
77
};
 
78
 
 
79
template<> class numeric_limits<cv bool>;
 
80
 
 
81
template<> class numeric_limits<cv char>;
 
82
template<> class numeric_limits<cv signed char>;
 
83
template<> class numeric_limits<cv unsigned char>;
 
84
template<> class numeric_limits<cv wchar_t>;
 
85
template<> class numeric_limits<cv char16_t>;
 
86
template<> class numeric_limits<cv char32_t>;
 
87
 
 
88
template<> class numeric_limits<cv short>;
 
89
template<> class numeric_limits<cv int>;
 
90
template<> class numeric_limits<cv long>;
 
91
template<> class numeric_limits<cv long long>;
 
92
template<> class numeric_limits<cv unsigned short>;
 
93
template<> class numeric_limits<cv unsigned int>;
 
94
template<> class numeric_limits<cv unsigned long>;
 
95
template<> class numeric_limits<cv unsigned long long>;
 
96
 
 
97
template<> class numeric_limits<cv float>;
 
98
template<> class numeric_limits<cv double>;
 
99
template<> class numeric_limits<cv long double>;
 
100
 
 
101
}  // std
 
102
 
 
103
*/
 
104
 
 
105
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 
106
#pragma GCC system_header
 
107
#endif
 
108
 
 
109
#include <__config>
 
110
#include <type_traits>
 
111
 
 
112
#include <__undef_min_max>
 
113
 
 
114
#if defined(_MSC_VER)
 
115
#include "support/win32/limits_win32.h"
 
116
#endif // _MSC_VER
 
117
 
 
118
_LIBCPP_BEGIN_NAMESPACE_STD
 
119
 
 
120
enum float_round_style
 
121
{
 
122
    round_indeterminate       = -1,
 
123
    round_toward_zero         =  0,
 
124
    round_to_nearest          =  1,
 
125
    round_toward_infinity     =  2,
 
126
    round_toward_neg_infinity =  3
 
127
};
 
128
 
 
129
enum float_denorm_style
 
130
{
 
131
    denorm_indeterminate = -1,
 
132
    denorm_absent = 0,
 
133
    denorm_present = 1
 
134
};
 
135
 
 
136
template <class _Tp, bool = is_arithmetic<_Tp>::value>
 
137
class __libcpp_numeric_limits
 
138
{
 
139
protected:
 
140
    typedef _Tp type;
 
141
 
 
142
    static _LIBCPP_CONSTEXPR const  bool is_specialized = false;
 
143
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type min() _NOEXCEPT {return type();}
 
144
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type max() _NOEXCEPT {return type();}
 
145
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT {return type();}
 
146
 
 
147
    static _LIBCPP_CONSTEXPR const int  digits = 0;
 
148
    static _LIBCPP_CONSTEXPR const int  digits10 = 0;
 
149
    static _LIBCPP_CONSTEXPR const int  max_digits10 = 0;
 
150
    static _LIBCPP_CONSTEXPR const bool is_signed = false;
 
151
    static _LIBCPP_CONSTEXPR const bool is_integer = false;
 
152
    static _LIBCPP_CONSTEXPR const bool is_exact = false;
 
153
    static _LIBCPP_CONSTEXPR const int  radix = 0;
 
154
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type epsilon() _NOEXCEPT {return type();}
 
155
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type round_error() _NOEXCEPT {return type();}
 
156
 
 
157
    static _LIBCPP_CONSTEXPR const int  min_exponent = 0;
 
158
    static _LIBCPP_CONSTEXPR const int  min_exponent10 = 0;
 
159
    static _LIBCPP_CONSTEXPR const int  max_exponent = 0;
 
160
    static _LIBCPP_CONSTEXPR const int  max_exponent10 = 0;
 
161
 
 
162
    static _LIBCPP_CONSTEXPR const bool has_infinity = false;
 
163
    static _LIBCPP_CONSTEXPR const bool has_quiet_NaN = false;
 
164
    static _LIBCPP_CONSTEXPR const bool has_signaling_NaN = false;
 
165
    static _LIBCPP_CONSTEXPR const float_denorm_style has_denorm = denorm_absent;
 
166
    static _LIBCPP_CONSTEXPR const bool has_denorm_loss = false;
 
167
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type infinity() _NOEXCEPT {return type();}
 
168
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type quiet_NaN() _NOEXCEPT {return type();}
 
169
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type signaling_NaN() _NOEXCEPT {return type();}
 
170
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type denorm_min() _NOEXCEPT {return type();}
 
171
 
 
172
    static _LIBCPP_CONSTEXPR const bool is_iec559 = false;
 
173
    static _LIBCPP_CONSTEXPR const bool is_bounded = false;
 
174
    static _LIBCPP_CONSTEXPR const bool is_modulo = false;
 
175
 
 
176
    static _LIBCPP_CONSTEXPR const bool traps = false;
 
177
    static _LIBCPP_CONSTEXPR const bool tinyness_before = false;
 
178
    static _LIBCPP_CONSTEXPR const float_round_style round_style = round_toward_zero;
 
179
};
 
180
 
 
181
template <class _Tp, int digits, bool is_signed>
 
182
struct __libcpp_compute_min
 
183
{
 
184
    static _LIBCPP_CONSTEXPR const _Tp value = _Tp(_Tp(1) << digits);
 
185
};
 
186
 
 
187
template <class _Tp, int digits>
 
188
struct __libcpp_compute_min<_Tp, digits, false>
 
189
{
 
190
    static _LIBCPP_CONSTEXPR const _Tp value = _Tp(0);
 
191
};
 
192
 
 
193
template <class _Tp>
 
194
class __libcpp_numeric_limits<_Tp, true>
 
195
{
 
196
protected:
 
197
    typedef _Tp type;
 
198
 
 
199
    static _LIBCPP_CONSTEXPR const bool is_specialized = true;
 
200
 
 
201
    static _LIBCPP_CONSTEXPR const bool is_signed = type(-1) < type(0);
 
202
    static _LIBCPP_CONSTEXPR const int  digits = static_cast<int>(sizeof(type) * __CHAR_BIT__ - is_signed);
 
203
    static _LIBCPP_CONSTEXPR const int  digits10 = digits * 3 / 10;
 
204
    static _LIBCPP_CONSTEXPR const int  max_digits10 = 0;
 
205
    static _LIBCPP_CONSTEXPR const type __min = __libcpp_compute_min<type, digits, is_signed>::value;
 
206
    static _LIBCPP_CONSTEXPR const type __max = is_signed ? type(type(~0) ^ __min) : type(~0);
 
207
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type min() _NOEXCEPT {return __min;}
 
208
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type max() _NOEXCEPT {return __max;}
 
209
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT {return min();}
 
210
 
 
211
    static _LIBCPP_CONSTEXPR const bool is_integer = true;
 
212
    static _LIBCPP_CONSTEXPR const bool is_exact = true;
 
213
    static _LIBCPP_CONSTEXPR const int  radix = 2;
 
214
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type epsilon() _NOEXCEPT {return type(0);}
 
215
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type round_error() _NOEXCEPT {return type(0);}
 
216
 
 
217
    static _LIBCPP_CONSTEXPR const int  min_exponent = 0;
 
218
    static _LIBCPP_CONSTEXPR const int  min_exponent10 = 0;
 
219
    static _LIBCPP_CONSTEXPR const int  max_exponent = 0;
 
220
    static _LIBCPP_CONSTEXPR const int  max_exponent10 = 0;
 
221
 
 
222
    static _LIBCPP_CONSTEXPR const bool has_infinity = false;
 
223
    static _LIBCPP_CONSTEXPR const bool has_quiet_NaN = false;
 
224
    static _LIBCPP_CONSTEXPR const bool has_signaling_NaN = false;
 
225
    static _LIBCPP_CONSTEXPR const float_denorm_style has_denorm = denorm_absent;
 
226
    static _LIBCPP_CONSTEXPR const bool has_denorm_loss = false;
 
227
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type infinity() _NOEXCEPT {return type(0);}
 
228
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type quiet_NaN() _NOEXCEPT {return type(0);}
 
229
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type signaling_NaN() _NOEXCEPT {return type(0);}
 
230
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type denorm_min() _NOEXCEPT {return type(0);}
 
231
 
 
232
    static _LIBCPP_CONSTEXPR const bool is_iec559 = false;
 
233
    static _LIBCPP_CONSTEXPR const bool is_bounded = true;
 
234
    static _LIBCPP_CONSTEXPR const bool is_modulo = true;
 
235
 
 
236
#if __i386__ || __x86_64__
 
237
    static _LIBCPP_CONSTEXPR const bool traps = true;
 
238
#else
 
239
    static _LIBCPP_CONSTEXPR const bool traps = false;
 
240
#endif
 
241
    static _LIBCPP_CONSTEXPR const bool tinyness_before = false;
 
242
    static _LIBCPP_CONSTEXPR const float_round_style round_style = round_toward_zero;
 
243
};
 
244
 
 
245
template <>
 
246
class __libcpp_numeric_limits<bool, true>
 
247
{
 
248
protected:
 
249
    typedef bool type;
 
250
 
 
251
    static _LIBCPP_CONSTEXPR const bool is_specialized = true;
 
252
 
 
253
    static _LIBCPP_CONSTEXPR const bool is_signed = false;
 
254
    static _LIBCPP_CONSTEXPR const int  digits = 1;
 
255
    static _LIBCPP_CONSTEXPR const int  digits10 = 0;
 
256
    static _LIBCPP_CONSTEXPR const int  max_digits10 = 0;
 
257
    static _LIBCPP_CONSTEXPR const type __min = false;
 
258
    static _LIBCPP_CONSTEXPR const type __max = true;
 
259
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type min() _NOEXCEPT {return __min;}
 
260
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type max() _NOEXCEPT {return __max;}
 
261
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT {return min();}
 
262
 
 
263
    static _LIBCPP_CONSTEXPR const bool is_integer = true;
 
264
    static _LIBCPP_CONSTEXPR const bool is_exact = true;
 
265
    static _LIBCPP_CONSTEXPR const int  radix = 2;
 
266
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type epsilon() _NOEXCEPT {return type(0);}
 
267
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type round_error() _NOEXCEPT {return type(0);}
 
268
 
 
269
    static _LIBCPP_CONSTEXPR const int  min_exponent = 0;
 
270
    static _LIBCPP_CONSTEXPR const int  min_exponent10 = 0;
 
271
    static _LIBCPP_CONSTEXPR const int  max_exponent = 0;
 
272
    static _LIBCPP_CONSTEXPR const int  max_exponent10 = 0;
 
273
 
 
274
    static _LIBCPP_CONSTEXPR const bool has_infinity = false;
 
275
    static _LIBCPP_CONSTEXPR const bool has_quiet_NaN = false;
 
276
    static _LIBCPP_CONSTEXPR const bool has_signaling_NaN = false;
 
277
    static _LIBCPP_CONSTEXPR const float_denorm_style has_denorm = denorm_absent;
 
278
    static _LIBCPP_CONSTEXPR const bool has_denorm_loss = false;
 
279
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type infinity() _NOEXCEPT {return type(0);}
 
280
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type quiet_NaN() _NOEXCEPT {return type(0);}
 
281
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type signaling_NaN() _NOEXCEPT {return type(0);}
 
282
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type denorm_min() _NOEXCEPT {return type(0);}
 
283
 
 
284
    static _LIBCPP_CONSTEXPR const bool is_iec559 = false;
 
285
    static _LIBCPP_CONSTEXPR const bool is_bounded = true;
 
286
    static _LIBCPP_CONSTEXPR const bool is_modulo = false;
 
287
 
 
288
    static _LIBCPP_CONSTEXPR const bool traps = false;
 
289
    static _LIBCPP_CONSTEXPR const bool tinyness_before = false;
 
290
    static _LIBCPP_CONSTEXPR const float_round_style round_style = round_toward_zero;
 
291
};
 
292
 
 
293
template <>
 
294
class __libcpp_numeric_limits<float, true>
 
295
{
 
296
protected:
 
297
    typedef float type;
 
298
 
 
299
    static _LIBCPP_CONSTEXPR const bool is_specialized = true;
 
300
 
 
301
    static _LIBCPP_CONSTEXPR const bool is_signed = true;
 
302
    static _LIBCPP_CONSTEXPR const int  digits = __FLT_MANT_DIG__;
 
303
    static _LIBCPP_CONSTEXPR const int  digits10 = __FLT_DIG__;
 
304
    static _LIBCPP_CONSTEXPR const int  max_digits10 = 2+(digits * 30103)/100000;
 
305
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type min() _NOEXCEPT {return __FLT_MIN__;}
 
306
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type max() _NOEXCEPT {return __FLT_MAX__;}
 
307
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT {return -max();}
 
308
 
 
309
    static _LIBCPP_CONSTEXPR const bool is_integer = false;
 
310
    static _LIBCPP_CONSTEXPR const bool is_exact = false;
 
311
    static _LIBCPP_CONSTEXPR const int  radix = __FLT_RADIX__;
 
312
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type epsilon() _NOEXCEPT {return __FLT_EPSILON__;}
 
313
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type round_error() _NOEXCEPT {return 0.5F;}
 
314
 
 
315
    static _LIBCPP_CONSTEXPR const int  min_exponent = __FLT_MIN_EXP__;
 
316
    static _LIBCPP_CONSTEXPR const int  min_exponent10 = __FLT_MIN_10_EXP__;
 
317
    static _LIBCPP_CONSTEXPR const int  max_exponent = __FLT_MAX_EXP__;
 
318
    static _LIBCPP_CONSTEXPR const int  max_exponent10 = __FLT_MAX_10_EXP__;
 
319
 
 
320
    static _LIBCPP_CONSTEXPR const bool has_infinity = true;
 
321
    static _LIBCPP_CONSTEXPR const bool has_quiet_NaN = true;
 
322
    static _LIBCPP_CONSTEXPR const bool has_signaling_NaN = true;
 
323
    static _LIBCPP_CONSTEXPR const float_denorm_style has_denorm = denorm_present;
 
324
    static _LIBCPP_CONSTEXPR const bool has_denorm_loss = false;
 
325
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type infinity() _NOEXCEPT {return __builtin_huge_valf();}
 
326
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type quiet_NaN() _NOEXCEPT {return __builtin_nanf("");}
 
327
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type signaling_NaN() _NOEXCEPT {return __builtin_nansf("");}
 
328
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type denorm_min() _NOEXCEPT {return __FLT_DENORM_MIN__;}
 
329
 
 
330
    static _LIBCPP_CONSTEXPR const bool is_iec559 = true;
 
331
    static _LIBCPP_CONSTEXPR const bool is_bounded = true;
 
332
    static _LIBCPP_CONSTEXPR const bool is_modulo = false;
 
333
 
 
334
    static _LIBCPP_CONSTEXPR const bool traps = false;
 
335
    static _LIBCPP_CONSTEXPR const bool tinyness_before = false;
 
336
    static _LIBCPP_CONSTEXPR const float_round_style round_style = round_to_nearest;
 
337
};
 
338
 
 
339
template <>
 
340
class __libcpp_numeric_limits<double, true>
 
341
{
 
342
protected:
 
343
    typedef double type;
 
344
 
 
345
    static _LIBCPP_CONSTEXPR const bool is_specialized = true;
 
346
 
 
347
    static _LIBCPP_CONSTEXPR const bool is_signed = true;
 
348
    static _LIBCPP_CONSTEXPR const int  digits = __DBL_MANT_DIG__;
 
349
    static _LIBCPP_CONSTEXPR const int  digits10 = __DBL_DIG__;
 
350
    static _LIBCPP_CONSTEXPR const int  max_digits10 = 2+(digits * 30103)/100000;
 
351
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type min() _NOEXCEPT {return __DBL_MIN__;}
 
352
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type max() _NOEXCEPT {return __DBL_MAX__;}
 
353
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT {return -max();}
 
354
 
 
355
    static _LIBCPP_CONSTEXPR const bool is_integer = false;
 
356
    static _LIBCPP_CONSTEXPR const bool is_exact = false;
 
357
    static _LIBCPP_CONSTEXPR const int  radix = __FLT_RADIX__;
 
358
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type epsilon() _NOEXCEPT {return __DBL_EPSILON__;}
 
359
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type round_error() _NOEXCEPT {return 0.5;}
 
360
 
 
361
    static _LIBCPP_CONSTEXPR const int  min_exponent = __DBL_MIN_EXP__;
 
362
    static _LIBCPP_CONSTEXPR const int  min_exponent10 = __DBL_MIN_10_EXP__;
 
363
    static _LIBCPP_CONSTEXPR const int  max_exponent = __DBL_MAX_EXP__;
 
364
    static _LIBCPP_CONSTEXPR const int  max_exponent10 = __DBL_MAX_10_EXP__;
 
365
 
 
366
    static _LIBCPP_CONSTEXPR const bool has_infinity = true;
 
367
    static _LIBCPP_CONSTEXPR const bool has_quiet_NaN = true;
 
368
    static _LIBCPP_CONSTEXPR const bool has_signaling_NaN = true;
 
369
    static _LIBCPP_CONSTEXPR const float_denorm_style has_denorm = denorm_present;
 
370
    static _LIBCPP_CONSTEXPR const bool has_denorm_loss = false;
 
371
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type infinity() _NOEXCEPT {return __builtin_huge_val();}
 
372
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type quiet_NaN() _NOEXCEPT {return __builtin_nan("");}
 
373
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type signaling_NaN() _NOEXCEPT {return __builtin_nans("");}
 
374
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type denorm_min() _NOEXCEPT {return __DBL_DENORM_MIN__;}
 
375
 
 
376
    static _LIBCPP_CONSTEXPR const bool is_iec559 = true;
 
377
    static _LIBCPP_CONSTEXPR const bool is_bounded = true;
 
378
    static _LIBCPP_CONSTEXPR const bool is_modulo = false;
 
379
 
 
380
    static _LIBCPP_CONSTEXPR const bool traps = false;
 
381
    static _LIBCPP_CONSTEXPR const bool tinyness_before = false;
 
382
    static _LIBCPP_CONSTEXPR const float_round_style round_style = round_to_nearest;
 
383
};
 
384
 
 
385
template <>
 
386
class __libcpp_numeric_limits<long double, true>
 
387
{
 
388
protected:
 
389
    typedef long double type;
 
390
 
 
391
    static _LIBCPP_CONSTEXPR const bool is_specialized = true;
 
392
 
 
393
    static _LIBCPP_CONSTEXPR const bool is_signed = true;
 
394
    static _LIBCPP_CONSTEXPR const int  digits = __LDBL_MANT_DIG__;
 
395
    static _LIBCPP_CONSTEXPR const int  digits10 = __LDBL_DIG__;
 
396
    static _LIBCPP_CONSTEXPR const int  max_digits10 = 2+(digits * 30103)/100000;
 
397
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type min() _NOEXCEPT {return __LDBL_MIN__;}
 
398
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type max() _NOEXCEPT {return __LDBL_MAX__;}
 
399
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT {return -max();}
 
400
 
 
401
    static _LIBCPP_CONSTEXPR const bool is_integer = false;
 
402
    static _LIBCPP_CONSTEXPR const bool is_exact = false;
 
403
    static _LIBCPP_CONSTEXPR const int  radix = __FLT_RADIX__;
 
404
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type epsilon() _NOEXCEPT {return __LDBL_EPSILON__;}
 
405
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type round_error() _NOEXCEPT {return 0.5;}
 
406
 
 
407
    static _LIBCPP_CONSTEXPR const int  min_exponent = __LDBL_MIN_EXP__;
 
408
    static _LIBCPP_CONSTEXPR const int  min_exponent10 = __LDBL_MIN_10_EXP__;
 
409
    static _LIBCPP_CONSTEXPR const int  max_exponent = __LDBL_MAX_EXP__;
 
410
    static _LIBCPP_CONSTEXPR const int  max_exponent10 = __LDBL_MAX_10_EXP__;
 
411
 
 
412
    static _LIBCPP_CONSTEXPR const bool has_infinity = true;
 
413
    static _LIBCPP_CONSTEXPR const bool has_quiet_NaN = true;
 
414
    static _LIBCPP_CONSTEXPR const bool has_signaling_NaN = true;
 
415
    static _LIBCPP_CONSTEXPR const float_denorm_style has_denorm = denorm_present;
 
416
    static _LIBCPP_CONSTEXPR const bool has_denorm_loss = false;
 
417
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type infinity() _NOEXCEPT {return __builtin_huge_vall();}
 
418
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type quiet_NaN() _NOEXCEPT {return __builtin_nanl("");}
 
419
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type signaling_NaN() _NOEXCEPT {return __builtin_nansl("");}
 
420
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type denorm_min() _NOEXCEPT {return __LDBL_DENORM_MIN__;}
 
421
 
 
422
#if (defined(__ppc__) || defined(__ppc64__))
 
423
    static _LIBCPP_CONSTEXPR const bool is_iec559 = false;
 
424
#else
 
425
    static _LIBCPP_CONSTEXPR const bool is_iec559 = true;
 
426
#endif
 
427
    static _LIBCPP_CONSTEXPR const bool is_bounded = true;
 
428
    static _LIBCPP_CONSTEXPR const bool is_modulo = false;
 
429
 
 
430
    static _LIBCPP_CONSTEXPR const bool traps = false;
 
431
    static _LIBCPP_CONSTEXPR const bool tinyness_before = false;
 
432
    static _LIBCPP_CONSTEXPR const float_round_style round_style = round_to_nearest;
 
433
};
 
434
 
 
435
template <class _Tp>
 
436
class _LIBCPP_TYPE_VIS numeric_limits
 
437
    : private __libcpp_numeric_limits<typename remove_cv<_Tp>::type>
 
438
{
 
439
    typedef __libcpp_numeric_limits<typename remove_cv<_Tp>::type> __base;
 
440
    typedef typename __base::type type;
 
441
public:
 
442
    static _LIBCPP_CONSTEXPR const bool is_specialized = __base::is_specialized;
 
443
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type min() _NOEXCEPT {return __base::min();}
 
444
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type max() _NOEXCEPT {return __base::max();}
 
445
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT {return __base::lowest();}
 
446
 
 
447
    static _LIBCPP_CONSTEXPR const int  digits = __base::digits;
 
448
    static _LIBCPP_CONSTEXPR const int  digits10 = __base::digits10;
 
449
    static _LIBCPP_CONSTEXPR const int  max_digits10 = __base::max_digits10;
 
450
    static _LIBCPP_CONSTEXPR const bool is_signed = __base::is_signed;
 
451
    static _LIBCPP_CONSTEXPR const bool is_integer = __base::is_integer;
 
452
    static _LIBCPP_CONSTEXPR const bool is_exact = __base::is_exact;
 
453
    static _LIBCPP_CONSTEXPR const int  radix = __base::radix;
 
454
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type epsilon() _NOEXCEPT {return __base::epsilon();}
 
455
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type round_error() _NOEXCEPT {return __base::round_error();}
 
456
 
 
457
    static _LIBCPP_CONSTEXPR const int  min_exponent = __base::min_exponent;
 
458
    static _LIBCPP_CONSTEXPR const int  min_exponent10 = __base::min_exponent10;
 
459
    static _LIBCPP_CONSTEXPR const int  max_exponent = __base::max_exponent;
 
460
    static _LIBCPP_CONSTEXPR const int  max_exponent10 = __base::max_exponent10;
 
461
 
 
462
    static _LIBCPP_CONSTEXPR const bool has_infinity = __base::has_infinity;
 
463
    static _LIBCPP_CONSTEXPR const bool has_quiet_NaN = __base::has_quiet_NaN;
 
464
    static _LIBCPP_CONSTEXPR const bool has_signaling_NaN = __base::has_signaling_NaN;
 
465
    static _LIBCPP_CONSTEXPR const float_denorm_style has_denorm = __base::has_denorm;
 
466
    static _LIBCPP_CONSTEXPR const bool has_denorm_loss = __base::has_denorm_loss;
 
467
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type infinity() _NOEXCEPT {return __base::infinity();}
 
468
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type quiet_NaN() _NOEXCEPT {return __base::quiet_NaN();}
 
469
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type signaling_NaN() _NOEXCEPT {return __base::signaling_NaN();}
 
470
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type denorm_min() _NOEXCEPT {return __base::denorm_min();}
 
471
 
 
472
    static _LIBCPP_CONSTEXPR const bool is_iec559 = __base::is_iec559;
 
473
    static _LIBCPP_CONSTEXPR const bool is_bounded = __base::is_bounded;
 
474
    static _LIBCPP_CONSTEXPR const bool is_modulo = __base::is_modulo;
 
475
 
 
476
    static _LIBCPP_CONSTEXPR const bool traps = __base::traps;
 
477
    static _LIBCPP_CONSTEXPR const bool tinyness_before = __base::tinyness_before;
 
478
    static _LIBCPP_CONSTEXPR const float_round_style round_style = __base::round_style;
 
479
};
 
480
 
 
481
template <class _Tp>
 
482
    _LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::is_specialized;
 
483
template <class _Tp>
 
484
    _LIBCPP_CONSTEXPR const int numeric_limits<_Tp>::digits;
 
485
template <class _Tp>
 
486
    _LIBCPP_CONSTEXPR const int numeric_limits<_Tp>::digits10;
 
487
template <class _Tp>
 
488
    _LIBCPP_CONSTEXPR const int numeric_limits<_Tp>::max_digits10;
 
489
template <class _Tp>
 
490
    _LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::is_signed;
 
491
template <class _Tp>
 
492
    _LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::is_integer;
 
493
template <class _Tp>
 
494
    _LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::is_exact;
 
495
template <class _Tp>
 
496
    _LIBCPP_CONSTEXPR const int numeric_limits<_Tp>::radix;
 
497
template <class _Tp>
 
498
    _LIBCPP_CONSTEXPR const int numeric_limits<_Tp>::min_exponent;
 
499
template <class _Tp>
 
500
    _LIBCPP_CONSTEXPR const int numeric_limits<_Tp>::min_exponent10;
 
501
template <class _Tp>
 
502
    _LIBCPP_CONSTEXPR const int numeric_limits<_Tp>::max_exponent;
 
503
template <class _Tp>
 
504
    _LIBCPP_CONSTEXPR const int numeric_limits<_Tp>::max_exponent10;
 
505
template <class _Tp>
 
506
    _LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::has_infinity;
 
507
template <class _Tp>
 
508
    _LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::has_quiet_NaN;
 
509
template <class _Tp>
 
510
    _LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::has_signaling_NaN;
 
511
template <class _Tp>
 
512
    _LIBCPP_CONSTEXPR const float_denorm_style numeric_limits<_Tp>::has_denorm;
 
513
template <class _Tp>
 
514
    _LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::has_denorm_loss;
 
515
template <class _Tp>
 
516
    _LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::is_iec559;
 
517
template <class _Tp>
 
518
    _LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::is_bounded;
 
519
template <class _Tp>
 
520
    _LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::is_modulo;
 
521
template <class _Tp>
 
522
    _LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::traps;
 
523
template <class _Tp>
 
524
    _LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::tinyness_before;
 
525
template <class _Tp>
 
526
    _LIBCPP_CONSTEXPR const float_round_style numeric_limits<_Tp>::round_style;
 
527
 
 
528
template <class _Tp>
 
529
class _LIBCPP_TYPE_VIS numeric_limits<const _Tp>
 
530
    : private numeric_limits<_Tp>
 
531
{
 
532
    typedef numeric_limits<_Tp> __base;
 
533
    typedef _Tp type;
 
534
public:
 
535
    static _LIBCPP_CONSTEXPR const bool is_specialized = __base::is_specialized;
 
536
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type min() _NOEXCEPT {return __base::min();}
 
537
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type max() _NOEXCEPT {return __base::max();}
 
538
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT {return __base::lowest();}
 
539
 
 
540
    static _LIBCPP_CONSTEXPR const int  digits = __base::digits;
 
541
    static _LIBCPP_CONSTEXPR const int  digits10 = __base::digits10;
 
542
    static _LIBCPP_CONSTEXPR const int  max_digits10 = __base::max_digits10;
 
543
    static _LIBCPP_CONSTEXPR const bool is_signed = __base::is_signed;
 
544
    static _LIBCPP_CONSTEXPR const bool is_integer = __base::is_integer;
 
545
    static _LIBCPP_CONSTEXPR const bool is_exact = __base::is_exact;
 
546
    static _LIBCPP_CONSTEXPR const int  radix = __base::radix;
 
547
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type epsilon() _NOEXCEPT {return __base::epsilon();}
 
548
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type round_error() _NOEXCEPT {return __base::round_error();}
 
549
 
 
550
    static _LIBCPP_CONSTEXPR const int  min_exponent = __base::min_exponent;
 
551
    static _LIBCPP_CONSTEXPR const int  min_exponent10 = __base::min_exponent10;
 
552
    static _LIBCPP_CONSTEXPR const int  max_exponent = __base::max_exponent;
 
553
    static _LIBCPP_CONSTEXPR const int  max_exponent10 = __base::max_exponent10;
 
554
 
 
555
    static _LIBCPP_CONSTEXPR const bool has_infinity = __base::has_infinity;
 
556
    static _LIBCPP_CONSTEXPR const bool has_quiet_NaN = __base::has_quiet_NaN;
 
557
    static _LIBCPP_CONSTEXPR const bool has_signaling_NaN = __base::has_signaling_NaN;
 
558
    static _LIBCPP_CONSTEXPR const float_denorm_style has_denorm = __base::has_denorm;
 
559
    static _LIBCPP_CONSTEXPR const bool has_denorm_loss = __base::has_denorm_loss;
 
560
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type infinity() _NOEXCEPT {return __base::infinity();}
 
561
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type quiet_NaN() _NOEXCEPT {return __base::quiet_NaN();}
 
562
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type signaling_NaN() _NOEXCEPT {return __base::signaling_NaN();}
 
563
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type denorm_min() _NOEXCEPT {return __base::denorm_min();}
 
564
 
 
565
    static _LIBCPP_CONSTEXPR const bool is_iec559 = __base::is_iec559;
 
566
    static _LIBCPP_CONSTEXPR const bool is_bounded = __base::is_bounded;
 
567
    static _LIBCPP_CONSTEXPR const bool is_modulo = __base::is_modulo;
 
568
 
 
569
    static _LIBCPP_CONSTEXPR const bool traps = __base::traps;
 
570
    static _LIBCPP_CONSTEXPR const bool tinyness_before = __base::tinyness_before;
 
571
    static _LIBCPP_CONSTEXPR const float_round_style round_style = __base::round_style;
 
572
};
 
573
 
 
574
template <class _Tp>
 
575
    _LIBCPP_CONSTEXPR const bool numeric_limits<const _Tp>::is_specialized;
 
576
template <class _Tp>
 
577
    _LIBCPP_CONSTEXPR const int numeric_limits<const _Tp>::digits;
 
578
template <class _Tp>
 
579
    _LIBCPP_CONSTEXPR const int numeric_limits<const _Tp>::digits10;
 
580
template <class _Tp>
 
581
    _LIBCPP_CONSTEXPR const int numeric_limits<const _Tp>::max_digits10;
 
582
template <class _Tp>
 
583
    _LIBCPP_CONSTEXPR const bool numeric_limits<const _Tp>::is_signed;
 
584
template <class _Tp>
 
585
    _LIBCPP_CONSTEXPR const bool numeric_limits<const _Tp>::is_integer;
 
586
template <class _Tp>
 
587
    _LIBCPP_CONSTEXPR const bool numeric_limits<const _Tp>::is_exact;
 
588
template <class _Tp>
 
589
    _LIBCPP_CONSTEXPR const int numeric_limits<const _Tp>::radix;
 
590
template <class _Tp>
 
591
    _LIBCPP_CONSTEXPR const int numeric_limits<const _Tp>::min_exponent;
 
592
template <class _Tp>
 
593
    _LIBCPP_CONSTEXPR const int numeric_limits<const _Tp>::min_exponent10;
 
594
template <class _Tp>
 
595
    _LIBCPP_CONSTEXPR const int numeric_limits<const _Tp>::max_exponent;
 
596
template <class _Tp>
 
597
    _LIBCPP_CONSTEXPR const int numeric_limits<const _Tp>::max_exponent10;
 
598
template <class _Tp>
 
599
    _LIBCPP_CONSTEXPR const bool numeric_limits<const _Tp>::has_infinity;
 
600
template <class _Tp>
 
601
    _LIBCPP_CONSTEXPR const bool numeric_limits<const _Tp>::has_quiet_NaN;
 
602
template <class _Tp>
 
603
    _LIBCPP_CONSTEXPR const bool numeric_limits<const _Tp>::has_signaling_NaN;
 
604
template <class _Tp>
 
605
    _LIBCPP_CONSTEXPR const float_denorm_style numeric_limits<const _Tp>::has_denorm;
 
606
template <class _Tp>
 
607
    _LIBCPP_CONSTEXPR const bool numeric_limits<const _Tp>::has_denorm_loss;
 
608
template <class _Tp>
 
609
    _LIBCPP_CONSTEXPR const bool numeric_limits<const _Tp>::is_iec559;
 
610
template <class _Tp>
 
611
    _LIBCPP_CONSTEXPR const bool numeric_limits<const _Tp>::is_bounded;
 
612
template <class _Tp>
 
613
    _LIBCPP_CONSTEXPR const bool numeric_limits<const _Tp>::is_modulo;
 
614
template <class _Tp>
 
615
    _LIBCPP_CONSTEXPR const bool numeric_limits<const _Tp>::traps;
 
616
template <class _Tp>
 
617
    _LIBCPP_CONSTEXPR const bool numeric_limits<const _Tp>::tinyness_before;
 
618
template <class _Tp>
 
619
    _LIBCPP_CONSTEXPR const float_round_style numeric_limits<const _Tp>::round_style;
 
620
 
 
621
template <class _Tp>
 
622
class _LIBCPP_TYPE_VIS numeric_limits<volatile _Tp>
 
623
    : private numeric_limits<_Tp>
 
624
{
 
625
    typedef numeric_limits<_Tp> __base;
 
626
    typedef _Tp type;
 
627
public:
 
628
    static _LIBCPP_CONSTEXPR const bool is_specialized = __base::is_specialized;
 
629
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type min() _NOEXCEPT {return __base::min();}
 
630
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type max() _NOEXCEPT {return __base::max();}
 
631
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT {return __base::lowest();}
 
632
 
 
633
    static _LIBCPP_CONSTEXPR const int  digits = __base::digits;
 
634
    static _LIBCPP_CONSTEXPR const int  digits10 = __base::digits10;
 
635
    static _LIBCPP_CONSTEXPR const int  max_digits10 = __base::max_digits10;
 
636
    static _LIBCPP_CONSTEXPR const bool is_signed = __base::is_signed;
 
637
    static _LIBCPP_CONSTEXPR const bool is_integer = __base::is_integer;
 
638
    static _LIBCPP_CONSTEXPR const bool is_exact = __base::is_exact;
 
639
    static _LIBCPP_CONSTEXPR const int  radix = __base::radix;
 
640
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type epsilon() _NOEXCEPT {return __base::epsilon();}
 
641
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type round_error() _NOEXCEPT {return __base::round_error();}
 
642
 
 
643
    static _LIBCPP_CONSTEXPR const int  min_exponent = __base::min_exponent;
 
644
    static _LIBCPP_CONSTEXPR const int  min_exponent10 = __base::min_exponent10;
 
645
    static _LIBCPP_CONSTEXPR const int  max_exponent = __base::max_exponent;
 
646
    static _LIBCPP_CONSTEXPR const int  max_exponent10 = __base::max_exponent10;
 
647
 
 
648
    static _LIBCPP_CONSTEXPR const bool has_infinity = __base::has_infinity;
 
649
    static _LIBCPP_CONSTEXPR const bool has_quiet_NaN = __base::has_quiet_NaN;
 
650
    static _LIBCPP_CONSTEXPR const bool has_signaling_NaN = __base::has_signaling_NaN;
 
651
    static _LIBCPP_CONSTEXPR const float_denorm_style has_denorm = __base::has_denorm;
 
652
    static _LIBCPP_CONSTEXPR const bool has_denorm_loss = __base::has_denorm_loss;
 
653
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type infinity() _NOEXCEPT {return __base::infinity();}
 
654
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type quiet_NaN() _NOEXCEPT {return __base::quiet_NaN();}
 
655
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type signaling_NaN() _NOEXCEPT {return __base::signaling_NaN();}
 
656
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type denorm_min() _NOEXCEPT {return __base::denorm_min();}
 
657
 
 
658
    static _LIBCPP_CONSTEXPR const bool is_iec559 = __base::is_iec559;
 
659
    static _LIBCPP_CONSTEXPR const bool is_bounded = __base::is_bounded;
 
660
    static _LIBCPP_CONSTEXPR const bool is_modulo = __base::is_modulo;
 
661
 
 
662
    static _LIBCPP_CONSTEXPR const bool traps = __base::traps;
 
663
    static _LIBCPP_CONSTEXPR const bool tinyness_before = __base::tinyness_before;
 
664
    static _LIBCPP_CONSTEXPR const float_round_style round_style = __base::round_style;
 
665
};
 
666
 
 
667
template <class _Tp>
 
668
    _LIBCPP_CONSTEXPR const bool numeric_limits<volatile _Tp>::is_specialized;
 
669
template <class _Tp>
 
670
    _LIBCPP_CONSTEXPR const int numeric_limits<volatile _Tp>::digits;
 
671
template <class _Tp>
 
672
    _LIBCPP_CONSTEXPR const int numeric_limits<volatile _Tp>::digits10;
 
673
template <class _Tp>
 
674
    _LIBCPP_CONSTEXPR const int numeric_limits<volatile _Tp>::max_digits10;
 
675
template <class _Tp>
 
676
    _LIBCPP_CONSTEXPR const bool numeric_limits<volatile _Tp>::is_signed;
 
677
template <class _Tp>
 
678
    _LIBCPP_CONSTEXPR const bool numeric_limits<volatile _Tp>::is_integer;
 
679
template <class _Tp>
 
680
    _LIBCPP_CONSTEXPR const bool numeric_limits<volatile _Tp>::is_exact;
 
681
template <class _Tp>
 
682
    _LIBCPP_CONSTEXPR const int numeric_limits<volatile _Tp>::radix;
 
683
template <class _Tp>
 
684
    _LIBCPP_CONSTEXPR const int numeric_limits<volatile _Tp>::min_exponent;
 
685
template <class _Tp>
 
686
    _LIBCPP_CONSTEXPR const int numeric_limits<volatile _Tp>::min_exponent10;
 
687
template <class _Tp>
 
688
    _LIBCPP_CONSTEXPR const int numeric_limits<volatile _Tp>::max_exponent;
 
689
template <class _Tp>
 
690
    _LIBCPP_CONSTEXPR const int numeric_limits<volatile _Tp>::max_exponent10;
 
691
template <class _Tp>
 
692
    _LIBCPP_CONSTEXPR const bool numeric_limits<volatile _Tp>::has_infinity;
 
693
template <class _Tp>
 
694
    _LIBCPP_CONSTEXPR const bool numeric_limits<volatile _Tp>::has_quiet_NaN;
 
695
template <class _Tp>
 
696
    _LIBCPP_CONSTEXPR const bool numeric_limits<volatile _Tp>::has_signaling_NaN;
 
697
template <class _Tp>
 
698
    _LIBCPP_CONSTEXPR const float_denorm_style numeric_limits<volatile _Tp>::has_denorm;
 
699
template <class _Tp>
 
700
    _LIBCPP_CONSTEXPR const bool numeric_limits<volatile _Tp>::has_denorm_loss;
 
701
template <class _Tp>
 
702
    _LIBCPP_CONSTEXPR const bool numeric_limits<volatile _Tp>::is_iec559;
 
703
template <class _Tp>
 
704
    _LIBCPP_CONSTEXPR const bool numeric_limits<volatile _Tp>::is_bounded;
 
705
template <class _Tp>
 
706
    _LIBCPP_CONSTEXPR const bool numeric_limits<volatile _Tp>::is_modulo;
 
707
template <class _Tp>
 
708
    _LIBCPP_CONSTEXPR const bool numeric_limits<volatile _Tp>::traps;
 
709
template <class _Tp>
 
710
    _LIBCPP_CONSTEXPR const bool numeric_limits<volatile _Tp>::tinyness_before;
 
711
template <class _Tp>
 
712
    _LIBCPP_CONSTEXPR const float_round_style numeric_limits<volatile _Tp>::round_style;
 
713
 
 
714
template <class _Tp>
 
715
class _LIBCPP_TYPE_VIS numeric_limits<const volatile _Tp>
 
716
    : private numeric_limits<_Tp>
 
717
{
 
718
    typedef numeric_limits<_Tp> __base;
 
719
    typedef _Tp type;
 
720
public:
 
721
    static _LIBCPP_CONSTEXPR const bool is_specialized = __base::is_specialized;
 
722
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type min() _NOEXCEPT {return __base::min();}
 
723
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type max() _NOEXCEPT {return __base::max();}
 
724
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT {return __base::lowest();}
 
725
 
 
726
    static _LIBCPP_CONSTEXPR const int  digits = __base::digits;
 
727
    static _LIBCPP_CONSTEXPR const int  digits10 = __base::digits10;
 
728
    static _LIBCPP_CONSTEXPR const int  max_digits10 = __base::max_digits10;
 
729
    static _LIBCPP_CONSTEXPR const bool is_signed = __base::is_signed;
 
730
    static _LIBCPP_CONSTEXPR const bool is_integer = __base::is_integer;
 
731
    static _LIBCPP_CONSTEXPR const bool is_exact = __base::is_exact;
 
732
    static _LIBCPP_CONSTEXPR const int  radix = __base::radix;
 
733
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type epsilon() _NOEXCEPT {return __base::epsilon();}
 
734
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type round_error() _NOEXCEPT {return __base::round_error();}
 
735
 
 
736
    static _LIBCPP_CONSTEXPR const int  min_exponent = __base::min_exponent;
 
737
    static _LIBCPP_CONSTEXPR const int  min_exponent10 = __base::min_exponent10;
 
738
    static _LIBCPP_CONSTEXPR const int  max_exponent = __base::max_exponent;
 
739
    static _LIBCPP_CONSTEXPR const int  max_exponent10 = __base::max_exponent10;
 
740
 
 
741
    static _LIBCPP_CONSTEXPR const bool has_infinity = __base::has_infinity;
 
742
    static _LIBCPP_CONSTEXPR const bool has_quiet_NaN = __base::has_quiet_NaN;
 
743
    static _LIBCPP_CONSTEXPR const bool has_signaling_NaN = __base::has_signaling_NaN;
 
744
    static _LIBCPP_CONSTEXPR const float_denorm_style has_denorm = __base::has_denorm;
 
745
    static _LIBCPP_CONSTEXPR const bool has_denorm_loss = __base::has_denorm_loss;
 
746
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type infinity() _NOEXCEPT {return __base::infinity();}
 
747
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type quiet_NaN() _NOEXCEPT {return __base::quiet_NaN();}
 
748
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type signaling_NaN() _NOEXCEPT {return __base::signaling_NaN();}
 
749
    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type denorm_min() _NOEXCEPT {return __base::denorm_min();}
 
750
 
 
751
    static _LIBCPP_CONSTEXPR const bool is_iec559 = __base::is_iec559;
 
752
    static _LIBCPP_CONSTEXPR const bool is_bounded = __base::is_bounded;
 
753
    static _LIBCPP_CONSTEXPR const bool is_modulo = __base::is_modulo;
 
754
 
 
755
    static _LIBCPP_CONSTEXPR const bool traps = __base::traps;
 
756
    static _LIBCPP_CONSTEXPR const bool tinyness_before = __base::tinyness_before;
 
757
    static _LIBCPP_CONSTEXPR const float_round_style round_style = __base::round_style;
 
758
};
 
759
 
 
760
template <class _Tp>
 
761
    _LIBCPP_CONSTEXPR const bool numeric_limits<const volatile _Tp>::is_specialized;
 
762
template <class _Tp>
 
763
    _LIBCPP_CONSTEXPR const int numeric_limits<const volatile _Tp>::digits;
 
764
template <class _Tp>
 
765
    _LIBCPP_CONSTEXPR const int numeric_limits<const volatile _Tp>::digits10;
 
766
template <class _Tp>
 
767
    const int numeric_limits<const volatile _Tp>::max_digits10;
 
768
template <class _Tp>
 
769
    _LIBCPP_CONSTEXPR const bool numeric_limits<const volatile _Tp>::is_signed;
 
770
template <class _Tp>
 
771
    _LIBCPP_CONSTEXPR const bool numeric_limits<const volatile _Tp>::is_integer;
 
772
template <class _Tp>
 
773
    _LIBCPP_CONSTEXPR const bool numeric_limits<const volatile _Tp>::is_exact;
 
774
template <class _Tp>
 
775
    _LIBCPP_CONSTEXPR const int numeric_limits<const volatile _Tp>::radix;
 
776
template <class _Tp>
 
777
    _LIBCPP_CONSTEXPR const int numeric_limits<const volatile _Tp>::min_exponent;
 
778
template <class _Tp>
 
779
    _LIBCPP_CONSTEXPR const int numeric_limits<const volatile _Tp>::min_exponent10;
 
780
template <class _Tp>
 
781
    _LIBCPP_CONSTEXPR const int numeric_limits<const volatile _Tp>::max_exponent;
 
782
template <class _Tp>
 
783
    _LIBCPP_CONSTEXPR const int numeric_limits<const volatile _Tp>::max_exponent10;
 
784
template <class _Tp>
 
785
    _LIBCPP_CONSTEXPR const bool numeric_limits<const volatile _Tp>::has_infinity;
 
786
template <class _Tp>
 
787
    _LIBCPP_CONSTEXPR const bool numeric_limits<const volatile _Tp>::has_quiet_NaN;
 
788
template <class _Tp>
 
789
    _LIBCPP_CONSTEXPR const bool numeric_limits<const volatile _Tp>::has_signaling_NaN;
 
790
template <class _Tp>
 
791
    _LIBCPP_CONSTEXPR const float_denorm_style numeric_limits<const volatile _Tp>::has_denorm;
 
792
template <class _Tp>
 
793
    _LIBCPP_CONSTEXPR const bool numeric_limits<const volatile _Tp>::has_denorm_loss;
 
794
template <class _Tp>
 
795
    _LIBCPP_CONSTEXPR const bool numeric_limits<const volatile _Tp>::is_iec559;
 
796
template <class _Tp>
 
797
    _LIBCPP_CONSTEXPR const bool numeric_limits<const volatile _Tp>::is_bounded;
 
798
template <class _Tp>
 
799
    _LIBCPP_CONSTEXPR const bool numeric_limits<const volatile _Tp>::is_modulo;
 
800
template <class _Tp>
 
801
    _LIBCPP_CONSTEXPR const bool numeric_limits<const volatile _Tp>::traps;
 
802
template <class _Tp>
 
803
    _LIBCPP_CONSTEXPR const bool numeric_limits<const volatile _Tp>::tinyness_before;
 
804
template <class _Tp>
 
805
    _LIBCPP_CONSTEXPR const float_round_style numeric_limits<const volatile _Tp>::round_style;
 
806
 
 
807
_LIBCPP_END_NAMESPACE_STD
 
808
 
 
809
#endif  // _LIBCPP_LIMITS