← Back to branch summary

~ubuntu-branches/ubuntu/hardy/libterralib/hardy

« back to all changes in this revision

Viewing changes to src/STLport/stl/_limits.h

  • Committer: Bazaar Package Importer
  • Author(s): Daniel T Chen
  • Date: 2005-11-25 22:32:59 UTC
  • Revision ID: james.westby@ubuntu.com-20051125223259-3zubal8ux4ki4fjg
Tags: upstream-3.0.3b2
Import upstream version 3.0.3b2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/STLport/stl/_limits.h
 
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_H
 
25
# define _STLP_INTERNAL_LIMITS_H
 
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_NO_WCHAR_T) && !defined (_STLP_CWCHAR_H)
 
36
# include <stl/_cwchar.h>
 
37
#endif
 
38
 
 
39
_STLP_BEGIN_NAMESPACE
 
40
 
 
41
enum 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
 
 
49
enum float_denorm_style {
 
50
  denorm_indeterminate = -1,
 
51
  denorm_absent        =  0,
 
52
  denorm_present       =  1
 
53
};
 
54
 
 
55
// Base class for all specializations of numeric_limits.
 
56
 
 
57
template <class __number>
 
58
class _Numeric_limits_base {
 
59
public:
 
60
 
 
61
  static __number (_STLP_CALL min)() _STLP_NOTHROW { return __number(); }
 
62
  static __number (_STLP_CALL max)() _STLP_NOTHROW { return __number(); }
 
63
 
 
64
# if defined ( _STLP_STATIC_CONST_INIT_BUG)
 
65
  enum {
 
66
# else
 
67
  static const int 
 
68
# endif
 
69
  
 
70
  digits = 0,
 
71
  digits10 = 0,
 
72
  radix = 0,
 
73
  min_exponent = 0,
 
74
  min_exponent10 = 0,
 
75
  max_exponent = 0,
 
76
  max_exponent10 = 0
 
77
 
 
78
# if defined ( _STLP_STATIC_CONST_INIT_BUG)
 
79
  ,  
 
80
  has_denorm = denorm_absent,
 
81
  round_style = round_toward_zero,
 
82
# else
 
83
  ;
 
84
  static const float_denorm_style has_denorm =  denorm_absent;
 
85
  static const float_round_style round_style = round_toward_zero;
 
86
  static const bool 
 
87
# endif
 
88
 
 
89
    is_specialized = false,
 
90
    is_signed  = false,
 
91
    is_integer = false,
 
92
    is_exact = false,
 
93
    has_infinity = false,
 
94
    has_quiet_NaN = false,
 
95
    has_signaling_NaN = false,
 
96
    has_denorm_loss = false,
 
97
    is_iec559 = false,
 
98
    is_bounded = false,
 
99
    is_modulo = false,
 
100
    traps = false,
 
101
    tinyness_before = false
 
102
# if defined ( _STLP_STATIC_CONST_INIT_BUG)
 
103
  }
 
104
# endif
 
105
  ;
 
106
    
 
107
  static __number _STLP_CALL epsilon() _STLP_NOTHROW     { return __number(); }
 
108
  static __number _STLP_CALL round_error() _STLP_NOTHROW { return __number(); }
 
109
 
 
110
  static __number _STLP_CALL infinity() _STLP_NOTHROW      { return __number(); }
 
111
  static __number _STLP_CALL quiet_NaN() _STLP_NOTHROW     { return __number(); }
 
112
  static __number _STLP_CALL signaling_NaN() _STLP_NOTHROW { return __number(); }
 
113
  static __number _STLP_CALL denorm_min() _STLP_NOTHROW    { return __number(); }
 
114
 
 
115
 
 
116
};
 
117
 
 
118
// Base class for integers.
 
119
 
 
120
# ifdef _STLP_LIMITED_DEFAULT_TEMPLATES
 
121
#  ifdef _STLP_LONG_LONG
 
122
#   define _STLP_LIMITS_MIN_TYPE _STLP_LONG_LONG
 
123
#   define _STLP_LIMITS_MAX_TYPE unsigned _STLP_LONG_LONG
 
124
#  else
 
125
#   define _STLP_LIMITS_MIN_TYPE long
 
126
#   define _STLP_LIMITS_MAX_TYPE unsigned long
 
127
#  endif
 
128
# else
 
129
#   define _STLP_LIMITS_MIN_TYPE _Int
 
130
#   define _STLP_LIMITS_MAX_TYPE _Int
 
131
# endif /* _STLP_LIMITED_DEFAULT_TEMPLATES */
 
132
 
 
133
template <class _Int,
 
134
          _STLP_LIMITS_MIN_TYPE __imin,
 
135
          _STLP_LIMITS_MAX_TYPE __imax,
 
136
          int __idigits, bool __ismod>
 
137
class _Integer_limits : public _Numeric_limits_base<_Int> 
 
138
{
 
139
public:
 
140
 
 
141
  static _Int (_STLP_CALL min) () _STLP_NOTHROW { return (_Int)__imin; }
 
142
  static _Int (_STLP_CALL max) () _STLP_NOTHROW { return (_Int)__imax; }
 
143
 
 
144
# if defined ( _STLP_STATIC_CONST_INIT_BUG)
 
145
  enum {
 
146
# else
 
147
  static const int 
 
148
# endif  
 
149
  digits = (__idigits < 0) ?
 
150
  ((int)((sizeof(_Int) * (CHAR_BIT))) - ((__imin == 0) ? 0 : 1))
 
151
  : (__idigits),
 
152
  digits10 = (digits * 301UL) / 1000,
 
153
  radix = 2
 
154
# if ! defined ( _STLP_STATIC_CONST_INIT_BUG)
 
155
  ;
 
156
  static const bool
 
157
# else
 
158
  ,
 
159
# endif
 
160
  is_specialized = true,
 
161
  is_signed = (__imin != 0),
 
162
  is_integer = true,
 
163
  is_exact = true,
 
164
  is_bounded = true,
 
165
  is_modulo = __ismod
 
166
# if defined ( _STLP_STATIC_CONST_INIT_BUG)
 
167
  }
 
168
# endif
 
169
  ;
 
170
};
 
171
 
 
172
// Base class for floating-point numbers.
 
173
template <class __number,
 
174
         int __Digits, int __Digits10,
 
175
         int __MinExp, int __MaxExp,
 
176
         int __MinExp10, int __MaxExp10,
 
177
         bool __IsIEC559,
 
178
         float_round_style __RoundStyle>
 
179
class _Floating_limits : public _Numeric_limits_base<__number>
 
180
{
 
181
public:
 
182
 
 
183
# if defined ( _STLP_STATIC_CONST_INIT_BUG)
 
184
  enum {
 
185
# else
 
186
  static const int 
 
187
# endif  
 
188
 
 
189
  digits = __Digits,
 
190
  digits10 = __Digits10,
 
191
 
 
192
  radix = (  FLT_RADIX /* 2 */ ),
 
193
  min_exponent = __MinExp, 
 
194
  max_exponent = __MaxExp,
 
195
  min_exponent10 = __MinExp10,
 
196
  max_exponent10 = __MaxExp10
 
197
 
 
198
# if defined (_STLP_STATIC_CONST_INIT_BUG)
 
199
  ,  
 
200
  has_denorm = denorm_indeterminate,
 
201
  round_style = __RoundStyle,
 
202
# else
 
203
  ;
 
204
  static const float_denorm_style has_denorm = denorm_indeterminate;
 
205
  static const float_round_style round_style = __RoundStyle;
 
206
  static const bool 
 
207
# endif
 
208
 
 
209
  is_specialized = true,
 
210
  is_signed = true, 
 
211
 
 
212
#if (!defined(_CRAY) || !defined(_CRAYIEEE))
 
213
   has_infinity     =  true,
 
214
   has_quiet_NaN    =  true,
 
215
   has_signaling_NaN=  true,
 
216
#else
 
217
  has_infinity     =  false,
 
218
  has_quiet_NaN    =  false,
 
219
  has_signaling_NaN=  false,
 
220
#endif
 
221
 
 
222
  has_denorm_loss  =  false,
 
223
  is_iec559      =  __IsIEC559,
 
224
  is_bounded     =  true,
 
225
  traps          =  true,
 
226
  tinyness_before=  false
 
227
 
 
228
# if defined ( _STLP_STATIC_CONST_INIT_BUG)
 
229
  }
 
230
# endif
 
231
  ;
 
232
 
 
233
};
 
234
 
 
235
// Class numeric_limits
 
236
 
 
237
// The unspecialized class.
 
238
 
 
239
template<class _Tp> 
 
240
class numeric_limits : public _Numeric_limits_base<_Tp> {};
 
241
 
 
242
// Specializations for all built-in integral types.
 
243
 
 
244
#ifndef _STLP_NO_BOOL
 
245
 
 
246
_STLP_TEMPLATE_NULL
 
247
class   numeric_limits<bool>
 
248
  : public _Integer_limits<bool, false, true, 1, false>
 
249
{};
 
250
 
 
251
#endif /* _STLP_NO_BOOL */
 
252
 
 
253
_STLP_TEMPLATE_NULL
 
254
class   numeric_limits<char>
 
255
  : public _Integer_limits<char, CHAR_MIN, CHAR_MAX, -1, true>
 
256
{};
 
257
 
 
258
# ifndef _STLP_NO_SIGNED_BUILTINS
 
259
_STLP_TEMPLATE_NULL
 
260
class   numeric_limits<signed char>
 
261
  : public _Integer_limits<signed char, SCHAR_MIN, SCHAR_MAX, -1, true>
 
262
{};
 
263
# endif
 
264
 
 
265
_STLP_TEMPLATE_NULL
 
266
class   numeric_limits<unsigned char>
 
267
  : public _Integer_limits<unsigned char, 0, UCHAR_MAX, -1, true>
 
268
{};
 
269
 
 
270
#if !(defined ( _STLP_NO_WCHAR_T ) || defined (_STLP_WCHAR_T_IS_USHORT))
 
271
 
 
272
_STLP_TEMPLATE_NULL
 
273
class   numeric_limits<wchar_t>
 
274
  : public _Integer_limits<wchar_t, WCHAR_MIN, WCHAR_MAX, -1, true>
 
275
{};
 
276
 
 
277
#endif
 
278
 
 
279
_STLP_TEMPLATE_NULL
 
280
class   numeric_limits<short>
 
281
  : public _Integer_limits<short, SHRT_MIN, SHRT_MAX, -1, true>
 
282
{};
 
283
 
 
284
_STLP_TEMPLATE_NULL
 
285
class   numeric_limits<unsigned short>
 
286
  : public _Integer_limits<unsigned short, 0, USHRT_MAX, -1, true>
 
287
{};
 
288
 
 
289
# if defined (__xlC__) && (__xlC__ == 0x500)
 
290
#  undef INT_MIN
 
291
#  define INT_MIN -2147483648
 
292
# endif
 
293
 
 
294
 
 
295
_STLP_TEMPLATE_NULL
 
296
class   numeric_limits<int>
 
297
  : public _Integer_limits<int, INT_MIN, INT_MAX, -1, true>
 
298
{};
 
299
 
 
300
_STLP_TEMPLATE_NULL
 
301
class   numeric_limits<unsigned int>
 
302
  : public _Integer_limits<unsigned int, 0, UINT_MAX, -1, true>
 
303
{};
 
304
 
 
305
_STLP_TEMPLATE_NULL
 
306
class   numeric_limits<long>
 
307
  : public _Integer_limits<long, LONG_MIN, LONG_MAX, -1, true>
 
308
{};
 
309
 
 
310
_STLP_TEMPLATE_NULL
 
311
class   numeric_limits<unsigned long>
 
312
  : public _Integer_limits<unsigned long, 0, ULONG_MAX, -1, true>
 
313
{};
 
314
 
 
315
#ifdef _STLP_LONG_LONG
 
316
 
 
317
# if defined (_STLP_MSVC) || defined (__BORLANDC__)
 
318
 
 
319
#    define LONGLONG_MAX     0x7fffffffffffffffi64
 
320
#    define LONGLONG_MIN     (-LONGLONG_MAX-1i64)
 
321
#    define ULONGLONG_MAX    0xffffffffffffffffUi64
 
322
 
 
323
# else
 
324
 
 
325
#  ifndef   LONGLONG_MAX
 
326
#    define LONGLONG_MAX     0x7fffffffffffffffLL
 
327
#  endif
 
328
#  ifndef   LONGLONG_MIN
 
329
#    define LONGLONG_MIN     (-LONGLONG_MAX-1LL)
 
330
#  endif
 
331
#  ifndef   ULONGLONG_MAX
 
332
#    define ULONGLONG_MAX    0xffffffffffffffffULL
 
333
#  endif
 
334
 
 
335
# endif
 
336
 
 
337
#if !defined(__GNUC__) || (__GNUC__ == 2 && __GNUC_MINOR__ <= 96)
 
338
 
 
339
_STLP_TEMPLATE_NULL
 
340
class   numeric_limits<_STLP_LONG_LONG>
 
341
  : public _Integer_limits<_STLP_LONG_LONG, LONGLONG_MIN, LONGLONG_MAX, -1, true>
 
342
{};
 
343
 
 
344
_STLP_TEMPLATE_NULL
 
345
class   numeric_limits<unsigned _STLP_LONG_LONG>
 
346
  : public _Integer_limits<unsigned _STLP_LONG_LONG, 0, ULONGLONG_MAX, -1, true>
 
347
{};
 
348
#else /* gcc 2.97 (after 2000-11-01), 2.98, 3.0 */
 
349
/*
 
350
 newest gcc has new mangling scheme, that has problem
 
351
 with generating name [instantiated] of template specialization like
 
352
 _Integer_limits<_STLP_LONG_LONG, LONGLONG_MIN, LONGLONG_MAX, -1, true>
 
353
                                  ~~~~~~~~~~~~  ~~~~~~~~~~~~
 
354
 Below is code that solve this problem.
 
355
   - ptr
 
356
 */
 
357
_STLP_TEMPLATE_NULL
 
358
class   numeric_limits<_STLP_LONG_LONG>
 
359
  : public _Numeric_limits_base<_STLP_LONG_LONG> 
 
360
{
 
361
public:
 
362
 
 
363
  static _STLP_LONG_LONG (_STLP_CALL min) () _STLP_NOTHROW { return LONGLONG_MIN; }
 
364
  static _STLP_LONG_LONG (_STLP_CALL max) () _STLP_NOTHROW { return LONGLONG_MAX; }
 
365
 
 
366
# if defined ( _STLP_STATIC_CONST_INIT_BUG)
 
367
  enum {
 
368
# else
 
369
  static const int 
 
370
# endif  
 
371
  digits = ((int)((sizeof(_STLP_LONG_LONG) * (CHAR_BIT))) - 1),
 
372
  digits10 = (digits * 301UL) / 1000,
 
373
  radix = 2
 
374
# if ! defined ( _STLP_STATIC_CONST_INIT_BUG)
 
375
  ;
 
376
  static const bool
 
377
# else
 
378
  ,
 
379
# endif
 
380
  is_specialized = true,
 
381
  is_signed = true,
 
382
  is_integer = true,
 
383
  is_exact = true,
 
384
  is_bounded = true,
 
385
  is_modulo = true
 
386
# if defined ( _STLP_STATIC_CONST_INIT_BUG)
 
387
  }
 
388
# endif
 
389
  ;
 
390
};
 
391
 
 
392
_STLP_TEMPLATE_NULL
 
393
class   numeric_limits<unsigned _STLP_LONG_LONG>
 
394
  : public _Numeric_limits_base<unsigned _STLP_LONG_LONG> 
 
395
{
 
396
public:
 
397
 
 
398
  static unsigned _STLP_LONG_LONG (_STLP_CALL min) () _STLP_NOTHROW { return 0ULL; }
 
399
  static unsigned _STLP_LONG_LONG (_STLP_CALL max) () _STLP_NOTHROW { return ULONGLONG_MAX; }
 
400
 
 
401
# if defined ( _STLP_STATIC_CONST_INIT_BUG)
 
402
  enum {
 
403
# else
 
404
  static const int 
 
405
# endif  
 
406
  digits = ((int)((sizeof(unsigned _STLP_LONG_LONG) * (CHAR_BIT)))),
 
407
  digits10 = (digits * 301UL) / 1000,
 
408
  radix = 2
 
409
# if ! defined ( _STLP_STATIC_CONST_INIT_BUG)
 
410
  ;
 
411
  static const bool
 
412
# else
 
413
  ,
 
414
# endif
 
415
  is_specialized = true,
 
416
  is_signed = false,
 
417
  is_integer = true,
 
418
  is_exact = true,
 
419
  is_bounded = true,
 
420
  is_modulo = true
 
421
# if defined ( _STLP_STATIC_CONST_INIT_BUG)
 
422
  }
 
423
# endif
 
424
  ;
 
425
};
 
426
 
 
427
# endif /* __GNUC__ > 2000-11-01 */
 
428
 
 
429
#endif /* _STLP_LONG_LONG */
 
430
 
 
431
// Specializations for all built-in floating-point types.
 
432
 
 
433
union _F_rep
 
434
{
 
435
  unsigned short rep[2];
 
436
  float val;
 
437
};
 
438
union _D_rep
 
439
{
 
440
  unsigned short rep[4];
 
441
  double val;
 
442
};
 
443
 
 
444
# ifndef _STLP_NO_LONG_DOUBLE
 
445
union _L_rep
 
446
{
 
447
  unsigned short rep[8];
 
448
  long double val;
 
449
};
 
450
# endif
 
451
 
 
452
template <class __dummy>
 
453
class _LimG 
 
454
{
 
455
public:  
 
456
  static const _F_rep _F_inf;
 
457
  static const _F_rep _F_qNaN;
 
458
  static const _F_rep _F_sNaN;
 
459
  static const _D_rep _D_inf;
 
460
  static const _D_rep _D_qNaN;
 
461
  static const _D_rep _D_sNaN;
 
462
  
 
463
# ifndef _STLP_NO_LONG_DOUBLE
 
464
  static const _L_rep _L_inf;
 
465
  static const _L_rep _L_qNaN;
 
466
  static const _L_rep _L_sNaN;
 
467
# endif
 
468
};
 
469
 
 
470
# if defined (_STLP_USE_TEMPLATE_EXPORT) 
 
471
_STLP_EXPORT_TEMPLATE_CLASS _LimG<bool>;
 
472
# endif
 
473
 
 
474
_STLP_TEMPLATE_NULL class   numeric_limits<float>
 
475
  : public _Floating_limits<float, 
 
476
                            FLT_MANT_DIG,   // Binary digits of precision
 
477
                            FLT_DIG,        // Decimal digits of precision
 
478
                            FLT_MIN_EXP,    // Minimum exponent
 
479
                            FLT_MAX_EXP,    // Maximum exponent
 
480
                            FLT_MIN_10_EXP, // Minimum base 10 exponent
 
481
                            FLT_MAX_10_EXP, // Maximum base 10 exponent
 
482
                            true,           // conforms to iec559
 
483
                            round_to_nearest>
 
484
{
 
485
public:
 
486
  static float (_STLP_CALL min) () _STLP_NOTHROW { return FLT_MIN; }
 
487
  static float _STLP_CALL denorm_min() _STLP_NOTHROW { return FLT_MIN; }
 
488
  static float (_STLP_CALL max) () _STLP_NOTHROW { _STLP_USING_VENDOR_CSTD return FLT_MAX; }
 
489
  static float _STLP_CALL epsilon() _STLP_NOTHROW { return FLT_EPSILON; }
 
490
  static float _STLP_CALL round_error() _STLP_NOTHROW { return 0.5f; } // Units: ulps.
 
491
  static  float _STLP_CALL infinity() { return _LimG<bool>::_F_inf.val; }
 
492
  static  float _STLP_CALL quiet_NaN() { return _LimG<bool>::_F_qNaN.val; }
 
493
  static  float _STLP_CALL signaling_NaN() { return _LimG<bool>::_F_sNaN.val; }
 
494
};
 
495
 
 
496
_STLP_TEMPLATE_NULL class   numeric_limits<double>
 
497
  : public _Floating_limits<double, 
 
498
                            DBL_MANT_DIG,   // Binary digits of precision
 
499
                            DBL_DIG,        // Decimal digits of precision
 
500
                            DBL_MIN_EXP,    // Minimum exponent
 
501
                            DBL_MAX_EXP,    // Maximum exponent
 
502
                            DBL_MIN_10_EXP, // Minimum base 10 exponent
 
503
                            DBL_MAX_10_EXP, // Maximum base 10 exponent
 
504
                            true,           // conforms to iec559
 
505
                            round_to_nearest>
 
506
{
 
507
public:
 
508
  static double (_STLP_CALL min)() _STLP_NOTHROW { return DBL_MIN; }
 
509
  static double _STLP_CALL denorm_min() _STLP_NOTHROW { return DBL_MIN; }
 
510
  static double (_STLP_CALL max)() _STLP_NOTHROW { _STLP_USING_VENDOR_CSTD return DBL_MAX; }
 
511
  static double _STLP_CALL epsilon() _STLP_NOTHROW { return DBL_EPSILON; }
 
512
  static double _STLP_CALL round_error() _STLP_NOTHROW { return 0.5; } // Units: ulps.
 
513
  static  double _STLP_CALL infinity() { return _LimG<bool>::_D_inf.val; }
 
514
  static  double _STLP_CALL quiet_NaN(){ return _LimG<bool>::_D_qNaN.val; }
 
515
  static  double _STLP_CALL signaling_NaN() { return _LimG<bool>::_D_sNaN.val; }
 
516
};
 
517
 
 
518
# ifndef _STLP_NO_LONG_DOUBLE
 
519
 
 
520
_STLP_TEMPLATE_NULL 
 
521
class   numeric_limits<long double>
 
522
  : public _Floating_limits<long double, 
 
523
                            LDBL_MANT_DIG,  // Binary digits of precision
 
524
                            LDBL_DIG,       // Decimal digits of precision
 
525
                            LDBL_MIN_EXP,   // Minimum exponent
 
526
                            LDBL_MAX_EXP,   // Maximum exponent
 
527
                            LDBL_MIN_10_EXP,// Minimum base 10 exponent
 
528
                            LDBL_MAX_10_EXP,// Maximum base 10 exponent
 
529
                            false,          // Doesn't conform to iec559
 
530
                            round_to_nearest>
 
531
{
 
532
public:
 
533
  static long double (_STLP_CALL min) () _STLP_NOTHROW { _STLP_USING_VENDOR_CSTD return LDBL_MIN; }
 
534
  static long double _STLP_CALL denorm_min() _STLP_NOTHROW { _STLP_USING_VENDOR_CSTD return LDBL_MIN; }
 
535
  static long double (_STLP_CALL max) () _STLP_NOTHROW { _STLP_USING_VENDOR_CSTD return LDBL_MAX; }
 
536
  static long double _STLP_CALL epsilon() _STLP_NOTHROW { return LDBL_EPSILON; }
 
537
  static long double _STLP_CALL round_error() _STLP_NOTHROW { return 4; } // Units: ulps.
 
538
  static long double _STLP_CALL infinity() { return _LimG<bool>::_L_inf.val; } 
 
539
  static long double _STLP_CALL quiet_NaN() { return _LimG<bool>::_L_qNaN.val; }
 
540
  static long double _STLP_CALL signaling_NaN() { return _LimG<bool>::_L_sNaN.val; }
 
541
};
 
542
 
 
543
# endif
 
544
 
 
545
// We write special values (Inf and NaN) as bit patterns and 
 
546
// cast the the appropriate floating-point types. 
 
547
_STLP_END_NAMESPACE
 
548
 
 
549
# if !defined (_STLP_LINK_TIME_INSTANTIATION)
 
550
#  include <stl/_limits.c>
 
551
# endif
 
552
 
 
553
#endif
 
554
 
 
555
// Local Variables:
 
556
// mode:C++
 
557
// End: