1/*
2 * Copyright (c) 1997
3 * Silicon Graphics Computer Systems, Inc.
4 *
5 * Copyright (c) 1999
6 * Boris Fomitchev
7 *
8 * This material is provided "as is", with absolutely no warranty expressed
9 * or implied. Any use is at your own risk.
10 *
11 * Permission to use or copy this software for any purpose is hereby granted
12 * without fee, provided the above notices are retained on all copies.
13 * Permission to modify the code and to distribute modified code is granted,
14 * provided the above notices are retained, and a notice that the code was
15 * modified is included with the above copyright notice.
16 *
17 */
18
19/* NOTE: This may be not portable code. Parts of numeric_limits<> are
20 * inherently machine-dependent.  At present this file is suitable
21 * for the MIPS, SPARC, Alpha and ia32 architectures.
22 */
23
24#ifndef _STLP_INTERNAL_LIMITS
25#define _STLP_INTERNAL_LIMITS
26
27#ifndef _STLP_CLIMITS
28#  include <climits>
29#endif
30
31#ifndef _STLP_CFLOAT
32#  include <cfloat>
33#endif
34
35#if defined (_STLP_HAS_WCHAR_T) && !defined (_STLP_INTERNAL_CWCHAR)
36#  include <stl/_cwchar.h>
37#endif
38
39_STLP_BEGIN_NAMESPACE
40
41enum float_round_style {
42  round_indeterminate       = -1,
43  round_toward_zero         =  0,
44  round_to_nearest          =  1,
45  round_toward_infinity     =  2,
46  round_toward_neg_infinity =  3
47};
48
49enum float_denorm_style {
50  denorm_indeterminate = -1,
51  denorm_absent        =  0,
52  denorm_present       =  1
53};
54
55_STLP_MOVE_TO_PRIV_NAMESPACE
56
57// Base class for all specializations of numeric_limits.
58template <class __number>
59class _Numeric_limits_base {
60public:
61
62  static __number (_STLP_CALL min)() _STLP_NOTHROW { return __number(); }
63  static __number (_STLP_CALL max)() _STLP_NOTHROW { return __number(); }
64
65  _STLP_STATIC_CONSTANT(int, digits = 0);
66  _STLP_STATIC_CONSTANT(int, digits10 = 0);
67  _STLP_STATIC_CONSTANT(int, radix = 0);
68  _STLP_STATIC_CONSTANT(int, min_exponent = 0);
69  _STLP_STATIC_CONSTANT(int, min_exponent10 = 0);
70  _STLP_STATIC_CONSTANT(int, max_exponent = 0);
71  _STLP_STATIC_CONSTANT(int, max_exponent10 = 0);
72
73  _STLP_STATIC_CONSTANT(float_denorm_style, has_denorm = denorm_absent);
74  _STLP_STATIC_CONSTANT(float_round_style, round_style = round_toward_zero);
75
76  _STLP_STATIC_CONSTANT(bool, is_specialized = false);
77  _STLP_STATIC_CONSTANT(bool, is_signed  = false);
78  _STLP_STATIC_CONSTANT(bool, is_integer = false);
79  _STLP_STATIC_CONSTANT(bool, is_exact = false);
80  _STLP_STATIC_CONSTANT(bool, has_infinity = false);
81  _STLP_STATIC_CONSTANT(bool, has_quiet_NaN = false);
82  _STLP_STATIC_CONSTANT(bool, has_signaling_NaN = false);
83  _STLP_STATIC_CONSTANT(bool, has_denorm_loss = false);
84  _STLP_STATIC_CONSTANT(bool, is_iec559 = false);
85  _STLP_STATIC_CONSTANT(bool, is_bounded = false);
86  _STLP_STATIC_CONSTANT(bool, is_modulo = false);
87  _STLP_STATIC_CONSTANT(bool, traps = false);
88  _STLP_STATIC_CONSTANT(bool, tinyness_before = false);
89
90  static __number _STLP_CALL epsilon() _STLP_NOTHROW     { return __number(); }
91  static __number _STLP_CALL round_error() _STLP_NOTHROW { return __number(); }
92
93  static __number _STLP_CALL infinity() _STLP_NOTHROW      { return __number(); }
94  static __number _STLP_CALL quiet_NaN() _STLP_NOTHROW     { return __number(); }
95  static __number _STLP_CALL signaling_NaN() _STLP_NOTHROW { return __number(); }
96  static __number _STLP_CALL denorm_min() _STLP_NOTHROW    { return __number(); }
97};
98
99// Base class for integers.
100
101#ifdef _STLP_LIMITED_DEFAULT_TEMPLATES
102#  ifdef _STLP_LONG_LONG
103#    define _STLP_LIMITS_MIN_TYPE _STLP_LONG_LONG
104#    define _STLP_LIMITS_MAX_TYPE unsigned _STLP_LONG_LONG
105#  else
106#    define _STLP_LIMITS_MIN_TYPE long
107#    define _STLP_LIMITS_MAX_TYPE unsigned long
108#  endif
109#else
110#  define _STLP_LIMITS_MIN_TYPE _Int
111#  define _STLP_LIMITS_MAX_TYPE _Int
112#endif /* _STLP_LIMITED_DEFAULT_TEMPLATES */
113
114template <class _Int,
115          _STLP_LIMITS_MIN_TYPE __imin,
116          _STLP_LIMITS_MAX_TYPE __imax,
117          int __idigits, bool __ismod>
118class _Integer_limits : public _Numeric_limits_base<_Int> {
119public:
120
121  static _Int (_STLP_CALL min) () _STLP_NOTHROW { return (_Int)__imin; }
122  static _Int (_STLP_CALL max) () _STLP_NOTHROW { return (_Int)__imax; }
123
124  _STLP_STATIC_CONSTANT(int, digits = (__idigits < 0) ? ((int)((sizeof(_Int) * (CHAR_BIT))) - ((__imin == 0) ? 0 : 1)) : (__idigits));
125  _STLP_STATIC_CONSTANT(int, digits10 = (digits * 301UL) / 1000);
126  _STLP_STATIC_CONSTANT(int, radix = 2);
127  _STLP_STATIC_CONSTANT(bool, is_specialized = true);
128  _STLP_STATIC_CONSTANT(bool, is_signed = (__imin != 0));
129  _STLP_STATIC_CONSTANT(bool, is_integer = true);
130  _STLP_STATIC_CONSTANT(bool, is_exact = true);
131  _STLP_STATIC_CONSTANT(bool, is_bounded = true);
132  _STLP_STATIC_CONSTANT(bool, is_modulo = __ismod);
133};
134
135// Base class for floating-point numbers.
136template <class __number,
137         int __Digits, int __Digits10,
138         int __MinExp, int __MaxExp,
139         int __MinExp10, int __MaxExp10,
140         bool __IsIEC559,
141         float_denorm_style __DenormStyle,
142         float_round_style __RoundStyle>
143class _Floating_limits : public _Numeric_limits_base<__number> {
144public:
145
146  _STLP_STATIC_CONSTANT(int, digits = __Digits);
147  _STLP_STATIC_CONSTANT(int, digits10 = __Digits10);
148  _STLP_STATIC_CONSTANT(int, radix = FLT_RADIX);
149  _STLP_STATIC_CONSTANT(int, min_exponent = __MinExp);
150  _STLP_STATIC_CONSTANT(int, max_exponent = __MaxExp);
151  _STLP_STATIC_CONSTANT(int, min_exponent10 = __MinExp10);
152  _STLP_STATIC_CONSTANT(int, max_exponent10 = __MaxExp10);
153
154  _STLP_STATIC_CONSTANT(float_denorm_style, has_denorm = __DenormStyle);
155  _STLP_STATIC_CONSTANT(float_round_style, round_style = __RoundStyle);
156
157  _STLP_STATIC_CONSTANT(bool, is_specialized = true);
158  _STLP_STATIC_CONSTANT(bool, is_signed = true);
159
160  _STLP_STATIC_CONSTANT(bool, has_infinity = true);
161#if (!defined (_STLP_MSVC) || (_STLP_MSVC > 1300)) && \
162    (!defined (__BORLANDC__) || (__BORLANDC__ >= 0x590)) && \
163    (!defined (_CRAY) || defined (_CRAYIEEE))
164  _STLP_STATIC_CONSTANT(bool, has_quiet_NaN = true);
165  _STLP_STATIC_CONSTANT(bool, has_signaling_NaN = true);
166#else
167  _STLP_STATIC_CONSTANT(bool, has_quiet_NaN = false);
168  _STLP_STATIC_CONSTANT(bool, has_signaling_NaN = false);
169#endif
170
171  _STLP_STATIC_CONSTANT(bool, is_iec559 = __IsIEC559 && has_infinity && has_quiet_NaN && has_signaling_NaN && (has_denorm == denorm_present));
172  _STLP_STATIC_CONSTANT(bool, has_denorm_loss =  false);
173  _STLP_STATIC_CONSTANT(bool, is_bounded = true);
174  _STLP_STATIC_CONSTANT(bool, traps = true);
175  _STLP_STATIC_CONSTANT(bool, tinyness_before = false);
176};
177
178_STLP_MOVE_TO_STD_NAMESPACE
179
180// Class numeric_limits
181
182// The unspecialized class.
183
184template<class _Tp>
185class numeric_limits : public _STLP_PRIV _Numeric_limits_base<_Tp> {};
186
187// Specializations for all built-in integral types.
188
189#if !defined (_STLP_NO_BOOL)
190_STLP_TEMPLATE_NULL
191class numeric_limits<bool>
192  : public _STLP_PRIV _Integer_limits<bool, false, true, 1, false>
193{};
194#endif /* _STLP_NO_BOOL */
195
196_STLP_TEMPLATE_NULL
197class numeric_limits<char>
198  : public _STLP_PRIV _Integer_limits<char, CHAR_MIN, CHAR_MAX, -1, true>
199{};
200
201#if !defined (_STLP_NO_SIGNED_BUILTINS)
202_STLP_TEMPLATE_NULL
203class numeric_limits<signed char>
204  : public _STLP_PRIV _Integer_limits<signed char, SCHAR_MIN, SCHAR_MAX, -1, true>
205{};
206#endif
207
208_STLP_TEMPLATE_NULL
209class numeric_limits<unsigned char>
210  : public _STLP_PRIV _Integer_limits<unsigned char, 0, UCHAR_MAX, -1, true>
211{};
212
213#if !(defined (_STLP_NO_WCHAR_T) || defined (_STLP_WCHAR_T_IS_USHORT))
214
215_STLP_TEMPLATE_NULL
216class numeric_limits<wchar_t>
217  : public _STLP_PRIV _Integer_limits<wchar_t, WCHAR_MIN, WCHAR_MAX, -1, true>
218{};
219
220#endif
221
222_STLP_TEMPLATE_NULL
223class numeric_limits<short>
224  : public _STLP_PRIV _Integer_limits<short, SHRT_MIN, SHRT_MAX, -1, true>
225{};
226
227_STLP_TEMPLATE_NULL
228class numeric_limits<unsigned short>
229  : public _STLP_PRIV _Integer_limits<unsigned short, 0, USHRT_MAX, -1, true>
230{};
231
232#if defined (__xlC__) && (__xlC__ == 0x500)
233#  undef INT_MIN
234#  define INT_MIN -2147483648
235#endif
236
237_STLP_TEMPLATE_NULL
238class numeric_limits<int>
239  : public _STLP_PRIV _Integer_limits<int, INT_MIN, INT_MAX, -1, true>
240{};
241
242_STLP_TEMPLATE_NULL
243class numeric_limits<unsigned int>
244  : public _STLP_PRIV _Integer_limits<unsigned int, 0, UINT_MAX, -1, true>
245{};
246
247_STLP_TEMPLATE_NULL
248class numeric_limits<long>
249  : public _STLP_PRIV _Integer_limits<long, LONG_MIN, LONG_MAX, -1, true>
250{};
251
252_STLP_TEMPLATE_NULL
253class numeric_limits<unsigned long>
254  : public _STLP_PRIV _Integer_limits<unsigned long, 0, ULONG_MAX, -1, true>
255{};
256
257#if defined (_STLP_LONG_LONG)
258
259#  if defined (_STLP_MSVC) || defined (__BORLANDC__)
260#    define LONGLONG_MAX     0x7fffffffffffffffi64
261#    define LONGLONG_MIN     (-LONGLONG_MAX-1i64)
262#    define ULONGLONG_MAX    0xffffffffffffffffUi64
263#  else
264#    ifndef LONGLONG_MAX
265#      define LONGLONG_MAX   0x7fffffffffffffffLL
266#    endif
267#    ifndef LONGLONG_MIN
268#      define LONGLONG_MIN   (-LONGLONG_MAX-1LL)
269#    endif
270#    ifndef ULONGLONG_MAX
271#      define ULONGLONG_MAX  0xffffffffffffffffULL
272#    endif
273#  endif
274
275#  if !defined (__GNUC__) || (__GNUC__ == 2 && __GNUC_MINOR__ <= 96) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 3)
276
277_STLP_TEMPLATE_NULL
278class numeric_limits<_STLP_LONG_LONG>
279  : public _STLP_PRIV _Integer_limits<_STLP_LONG_LONG, LONGLONG_MIN, LONGLONG_MAX, -1, true>
280{};
281
282_STLP_TEMPLATE_NULL
283class numeric_limits<unsigned _STLP_LONG_LONG>
284  : public _STLP_PRIV _Integer_limits<unsigned _STLP_LONG_LONG, 0, ULONGLONG_MAX, -1, true>
285{};
286#  else /* gcc 2.97 (after 2000-11-01), 2.98, 3.0 */
287/*
288 newest gcc has new mangling scheme, that has problem
289 with generating name [instantiated] of template specialization like
290 _Integer_limits<_STLP_LONG_LONG, LONGLONG_MIN, LONGLONG_MAX, -1, true>
291                                  ~~~~~~~~~~~~  ~~~~~~~~~~~~
292 Below is code that solve this problem.
293   - ptr
294 */
295_STLP_TEMPLATE_NULL
296class numeric_limits<_STLP_LONG_LONG>
297  : public _STLP_PRIV _Numeric_limits_base<_STLP_LONG_LONG> {
298public:
299
300  static _STLP_LONG_LONG (_STLP_CALL min) () _STLP_NOTHROW { return LONGLONG_MIN; }
301  static _STLP_LONG_LONG (_STLP_CALL max) () _STLP_NOTHROW { return LONGLONG_MAX; }
302
303  _STLP_STATIC_CONSTANT(int, digits = ((int)((sizeof(_STLP_LONG_LONG) * (CHAR_BIT))) - 1));
304  _STLP_STATIC_CONSTANT(int, digits10 = (digits * 301UL) / 1000);
305  _STLP_STATIC_CONSTANT(int, radix = 2);
306  _STLP_STATIC_CONSTANT(bool, is_specialized = true);
307  _STLP_STATIC_CONSTANT(bool, is_signed = true);
308  _STLP_STATIC_CONSTANT(bool, is_integer = true);
309  _STLP_STATIC_CONSTANT(bool, is_exact = true);
310  _STLP_STATIC_CONSTANT(bool, is_bounded = true);
311  _STLP_STATIC_CONSTANT(bool, is_modulo = true);
312};
313
314_STLP_TEMPLATE_NULL
315class numeric_limits<unsigned _STLP_LONG_LONG>
316  : public _STLP_PRIV _Numeric_limits_base<unsigned _STLP_LONG_LONG> {
317public:
318
319  static unsigned _STLP_LONG_LONG (_STLP_CALL min) () _STLP_NOTHROW { return 0ULL; }
320  static unsigned _STLP_LONG_LONG (_STLP_CALL max) () _STLP_NOTHROW { return ULONGLONG_MAX; }
321
322  _STLP_STATIC_CONSTANT(int, digits = ((int)((sizeof(unsigned _STLP_LONG_LONG) * (CHAR_BIT)))));
323  _STLP_STATIC_CONSTANT(int, digits10 = (digits * 301UL) / 1000);
324  _STLP_STATIC_CONSTANT(int, radix = 2);
325  _STLP_STATIC_CONSTANT(bool, is_specialized = true);
326  _STLP_STATIC_CONSTANT(bool, is_signed = false);
327  _STLP_STATIC_CONSTANT(bool, is_integer = true);
328  _STLP_STATIC_CONSTANT(bool, is_exact = true);
329  _STLP_STATIC_CONSTANT(bool, is_bounded = true);
330  _STLP_STATIC_CONSTANT(bool, is_modulo = true);
331};
332
333#  endif /* __GNUC__ > 2000-11-01 */
334
335#endif /* _STLP_LONG_LONG */
336
337_STLP_MOVE_TO_PRIV_NAMESPACE
338
339// Specializations for all built-in floating-point types.
340template <class __dummy>
341class _LimG {
342public:
343  static float _STLP_CALL get_F_inf();
344  static float _STLP_CALL get_F_qNaN();
345  static float _STLP_CALL get_F_sNaN();
346  static float _STLP_CALL get_F_denormMin();
347  static double _STLP_CALL get_D_inf();
348  static double _STLP_CALL get_D_qNaN();
349  static double _STLP_CALL get_D_sNaN();
350  static double _STLP_CALL get_D_denormMin();
351
352#if !defined (_STLP_NO_LONG_DOUBLE)
353  static long double _STLP_CALL get_LD_inf();
354  static long double _STLP_CALL get_LD_qNaN();
355  static long double _STLP_CALL get_LD_sNaN();
356  static long double _STLP_CALL get_LD_denormMin();
357#endif
358};
359
360#if defined (_STLP_USE_TEMPLATE_EXPORT)
361_STLP_EXPORT_TEMPLATE_CLASS _LimG<bool>;
362#endif
363
364#if defined (__GNUC__)
365#  if defined (__FLT_DENORM_MIN__)
366#    define _STLP_FLT_DENORM_MIN __FLT_DENORM_MIN__
367#  else
368#    define _STLP_FLT_DENORM_STYLE denorm_absent
369#  endif
370#  if defined (__DBL_DENORM_MIN__)
371#    define _STLP_DBL_DENORM_MIN __DBL_DENORM_MIN__
372#  else
373#    define _STLP_DBL_DENORM_STYLE denorm_absent
374#  endif
375#  if defined (__LDBL_DENORM_MIN__)
376#    define _STLP_LDBL_DENORM_MIN __LDBL_DENORM_MIN__
377#  else
378#    define _STLP_LDBL_DENORM_STYLE denorm_absent
379#  endif
380#endif
381
382/* If compiler do not expose thanks to some macro its status regarding
383 * denormalized floating point numbers, we consider that denormalization
384 * is present. Unit tests will tell us if compiler do not support them. */
385#if !defined (_STLP_FLT_DENORM_STYLE)
386#  define _STLP_FLT_DENORM_STYLE denorm_present
387#endif
388
389#if !defined (_STLP_DBL_DENORM_STYLE)
390#  define _STLP_DBL_DENORM_STYLE denorm_present
391#endif
392
393#if !defined (_STLP_LDBL_DENORM_STYLE)
394#  define _STLP_LDBL_DENORM_STYLE denorm_present
395#endif
396
397_STLP_MOVE_TO_STD_NAMESPACE
398
399_STLP_TEMPLATE_NULL
400class numeric_limits<float>
401  : public _STLP_PRIV _Floating_limits<float,
402                                       FLT_MANT_DIG,   // Binary digits of precision
403                                       FLT_DIG,        // Decimal digits of precision
404                                       FLT_MIN_EXP,    // Minimum exponent
405                                       FLT_MAX_EXP,    // Maximum exponent
406                                       FLT_MIN_10_EXP, // Minimum base 10 exponent
407                                       FLT_MAX_10_EXP, // Maximum base 10 exponent
408                                       true,
409                                       _STLP_FLT_DENORM_STYLE,
410                                       round_to_nearest> {
411public:
412  static float (_STLP_CALL min) () _STLP_NOTHROW { return FLT_MIN; }
413  static float _STLP_CALL denorm_min() _STLP_NOTHROW
414#if defined (_STLP_FLT_DENORM_MIN)
415  { return _STLP_FLT_DENORM_MIN; }
416#else
417  { return _STLP_FLT_DENORM_STYLE ? _STLP_PRIV _LimG<bool>::get_F_denormMin() : FLT_MIN; }
418#endif
419  static float (_STLP_CALL max) () _STLP_NOTHROW { return FLT_MAX; }
420  static float _STLP_CALL epsilon() _STLP_NOTHROW { return FLT_EPSILON; }
421  static float _STLP_CALL round_error() _STLP_NOTHROW { return 0.5f; } // Units: ulps.
422  static  float _STLP_CALL infinity() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_F_inf(); }
423  static  float _STLP_CALL quiet_NaN() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_F_qNaN(); }
424  static  float _STLP_CALL signaling_NaN() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_F_sNaN(); }
425};
426
427#undef _STLP_FLT_DENORM_MIN
428#undef _STLP_FLT_DNORM_STYLE
429
430_STLP_TEMPLATE_NULL
431class numeric_limits<double>
432  : public _STLP_PRIV _Floating_limits<double,
433                                       DBL_MANT_DIG,   // Binary digits of precision
434                                       DBL_DIG,        // Decimal digits of precision
435                                       DBL_MIN_EXP,    // Minimum exponent
436                                       DBL_MAX_EXP,    // Maximum exponent
437                                       DBL_MIN_10_EXP, // Minimum base 10 exponent
438                                       DBL_MAX_10_EXP, // Maximum base 10 exponent
439                                       true,
440                                       _STLP_DBL_DENORM_STYLE,
441                                       round_to_nearest> {
442public:
443  static double (_STLP_CALL min)() _STLP_NOTHROW { return DBL_MIN; }
444  static double _STLP_CALL denorm_min() _STLP_NOTHROW
445#if defined (_STLP_DBL_DENORM_MIN)
446  { return _STLP_DBL_DENORM_MIN; }
447#else
448  { return _STLP_DBL_DENORM_STYLE ? _STLP_PRIV _LimG<bool>::get_D_denormMin() : DBL_MIN; }
449#endif
450  static double (_STLP_CALL max)() _STLP_NOTHROW { return DBL_MAX; }
451  static double _STLP_CALL epsilon() _STLP_NOTHROW { return DBL_EPSILON; }
452  static double _STLP_CALL round_error() _STLP_NOTHROW { return 0.5; } // Units: ulps.
453  static  double _STLP_CALL infinity() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_D_inf(); }
454  static  double _STLP_CALL quiet_NaN() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_D_qNaN(); }
455  static  double _STLP_CALL signaling_NaN() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_D_sNaN(); }
456};
457
458#if !defined (_STLP_NO_LONG_DOUBLE)
459
460_STLP_TEMPLATE_NULL
461class numeric_limits<long double>
462  : public _STLP_PRIV _Floating_limits<long double,
463                                       LDBL_MANT_DIG,  // Binary digits of precision
464                                       LDBL_DIG,       // Decimal digits of precision
465                                       LDBL_MIN_EXP,   // Minimum exponent
466                                       LDBL_MAX_EXP,   // Maximum exponent
467                                       LDBL_MIN_10_EXP,// Minimum base 10 exponent
468                                       LDBL_MAX_10_EXP,// Maximum base 10 exponent
469                                       false,          // do not conform to iec559
470                                       _STLP_LDBL_DENORM_STYLE,
471                                       round_to_nearest> {
472public:
473  static long double (_STLP_CALL min) () _STLP_NOTHROW { return LDBL_MIN; }
474  static long double _STLP_CALL denorm_min() _STLP_NOTHROW
475#if defined (_STLP_LDBL_DENORM_MIN)
476  { return _STLP_LDBL_DENORM_MIN; }
477#else
478  { return _STLP_LDBL_DENORM_STYLE ? _STLP_PRIV _LimG<bool>::get_LD_denormMin() : LDBL_MIN; }
479#endif
480  _STLP_STATIC_CONSTANT(bool, is_iec559 = false);
481  static long double (_STLP_CALL max) () _STLP_NOTHROW { return LDBL_MAX; }
482  static long double _STLP_CALL epsilon() _STLP_NOTHROW { return LDBL_EPSILON; }
483  static long double _STLP_CALL round_error() _STLP_NOTHROW { return 0.5l; }
484  static long double _STLP_CALL infinity() _STLP_NOTHROW
485  //For MSVC, long double is nothing more than an alias for double.
486#if !defined (_STLP_MSVC)
487  { return _STLP_PRIV _LimG<bool>::get_LD_inf(); }
488#else
489  { return _STLP_PRIV _LimG<bool>::get_D_inf(); }
490#endif
491  static long double _STLP_CALL quiet_NaN() _STLP_NOTHROW
492#if !defined (_STLP_MSVC)
493  { return _STLP_PRIV _LimG<bool>::get_LD_qNaN(); }
494#else
495  { return _STLP_PRIV _LimG<bool>::get_D_qNaN(); }
496#endif
497  static long double _STLP_CALL signaling_NaN() _STLP_NOTHROW
498#if !defined (_STLP_MSVC)
499  { return _STLP_PRIV _LimG<bool>::get_LD_sNaN(); }
500#else
501  { return _STLP_PRIV _LimG<bool>::get_D_sNaN(); }
502#endif
503};
504
505#endif
506
507// We write special values (Inf and NaN) as bit patterns and
508// cast the the appropriate floating-point types.
509_STLP_END_NAMESPACE
510
511#if !defined (_STLP_LINK_TIME_INSTANTIATION)
512#  include <stl/_limits.c>
513#endif
514
515#endif
516
517// Local Variables:
518// mode:C++
519// End:
520