1 : // limits standard header
2 : #pragma once
3 : #ifndef _LIMITS_
4 : #define _LIMITS_
5 : #ifndef RC_INVOKED
6 : #include <ymath.h>
7 : #include <cfloat>
8 : #include <climits>
9 : #include <cmath>
10 : #include <cwchar>
11 : #include <xstddef>
12 :
13 : #ifdef _MSC_VER
14 : #pragma pack(push,_CRT_PACKING)
15 : #pragma warning(push,3)
16 : #endif /* _MSC_VER */
17 :
18 : _STD_BEGIN
19 :
20 : // ASSUMES:
21 : // wraparound 2's complement integer arithmetic w/o traps
22 : // all CHAR_BITs of each byte used by integers
23 : // IEC559 (IEEE 754) floating-point arithmetic
24 : // floating-point errors can trap
25 : // tinyness detected before floating-point rounding
26 : // 64-bit long long (if _LONGLONG defined)
27 :
28 : // ENUM float_denorm_style
29 : typedef enum
30 : { // constants for different IEEE float denormalization styles
31 : denorm_indeterminate = -1,
32 : denorm_absent = 0,
33 : denorm_present = 1}
34 : float_denorm_style;
35 :
36 : // ENUM float_round_style
37 : typedef enum
38 : { // constants for different IEEE rounding styles
39 : round_indeterminate = -1,
40 : round_toward_zero = 0,
41 : round_to_nearest = 1,
42 : round_toward_infinity = 2,
43 : round_toward_neg_infinity = 3}
44 : float_round_style;
45 :
46 : // STRUCT _Num_base
47 : struct _CRTIMP2_PURE _Num_base
48 : { // base for all types, with common defaults
49 : _STCONS(float_denorm_style, has_denorm, denorm_absent);
50 : _STCONS(bool, has_denorm_loss, false);
51 : _STCONS(bool, has_infinity, false);
52 : _STCONS(bool, has_quiet_NaN, false);
53 : _STCONS(bool, has_signaling_NaN, false);
54 : _STCONS(bool, is_bounded, false);
55 : _STCONS(bool, is_exact, false);
56 : _STCONS(bool, is_iec559, false);
57 : _STCONS(bool, is_integer, false);
58 : _STCONS(bool, is_modulo, false);
59 : _STCONS(bool, is_signed, false);
60 : _STCONS(bool, is_specialized, false);
61 : _STCONS(bool, tinyness_before, false);
62 : _STCONS(bool, traps, false);
63 : _STCONS(float_round_style, round_style, round_toward_zero);
64 : _STCONS(int, digits, 0);
65 : _STCONS(int, digits10, 0);
66 : _STCONS(int, max_exponent, 0);
67 : _STCONS(int, max_exponent10, 0);
68 : _STCONS(int, min_exponent, 0);
69 : _STCONS(int, min_exponent10, 0);
70 : _STCONS(int, radix, 0);
71 : };
72 :
73 : _STCONSDEF(_Num_base, float_denorm_style, has_denorm)
74 : _STCONSDEF(_Num_base, bool, has_denorm_loss)
75 : _STCONSDEF(_Num_base, bool, has_infinity)
76 : _STCONSDEF(_Num_base, bool, has_quiet_NaN)
77 : _STCONSDEF(_Num_base, bool, has_signaling_NaN)
78 : _STCONSDEF(_Num_base, bool, is_bounded)
79 : _STCONSDEF(_Num_base, bool, is_exact)
80 : _STCONSDEF(_Num_base, bool, is_iec559)
81 : _STCONSDEF(_Num_base, bool, is_integer)
82 : _STCONSDEF(_Num_base, bool, is_modulo)
83 : _STCONSDEF(_Num_base, bool, is_signed)
84 : _STCONSDEF(_Num_base, bool, is_specialized)
85 : _STCONSDEF(_Num_base, bool, tinyness_before)
86 : _STCONSDEF(_Num_base, bool, traps)
87 : _STCONSDEF(_Num_base, float_round_style, round_style)
88 : _STCONSDEF(_Num_base, int, digits)
89 : _STCONSDEF(_Num_base, int, digits10)
90 : _STCONSDEF(_Num_base, int, max_exponent)
91 : _STCONSDEF(_Num_base, int, max_exponent10)
92 : _STCONSDEF(_Num_base, int, min_exponent)
93 : _STCONSDEF(_Num_base, int, min_exponent10)
94 : _STCONSDEF(_Num_base, int, radix)
95 :
96 : // TEMPLATE CLASS numeric_limits
97 : template<class _Ty>
98 : class numeric_limits
99 : : public _Num_base
100 : { // numeric limits for arbitrary type _Ty (say little or nothing)
101 : public:
102 : static _Ty (__CRTDECL min)() _THROW0()
103 : { // return minimum value
104 : return (_Ty(0));
105 : }
106 :
107 : static _Ty (__CRTDECL max)() _THROW0()
108 : { // return maximum value
109 : return (_Ty(0));
110 : }
111 :
112 : static _Ty __CRTDECL epsilon() _THROW0()
113 : { // return smallest effective increment from 1.0
114 : return (_Ty(0));
115 : }
116 :
117 : static _Ty __CRTDECL round_error() _THROW0()
118 : { // return largest rounding error
119 : return (_Ty(0));
120 : }
121 :
122 : static _Ty __CRTDECL denorm_min() _THROW0()
123 : { // return minimum denormalized value
124 : return (_Ty(0));
125 : }
126 :
127 : static _Ty __CRTDECL infinity() _THROW0()
128 : { // return positive infinity
129 : return (_Ty(0));
130 : }
131 :
132 : static _Ty __CRTDECL quiet_NaN() _THROW0()
133 : { // return non-signaling NaN
134 : return (_Ty(0));
135 : }
136 :
137 : static _Ty __CRTDECL signaling_NaN() _THROW0()
138 : { // return signaling NaN
139 : return (_Ty(0));
140 : }
141 : };
142 :
143 : // STRUCT _Num_int_base
144 : struct _CRTIMP2_PURE _Num_int_base
145 : : public _Num_base
146 : { // base for integer types
147 : _STCONS(bool, is_bounded, true);
148 : _STCONS(bool, is_exact, true);
149 : _STCONS(bool, is_integer, true);
150 : _STCONS(bool, is_modulo, true);
151 : _STCONS(bool, is_specialized, true);
152 : _STCONS(int, radix, 2);
153 : };
154 :
155 : _STCONSDEF(_Num_int_base, bool, is_bounded)
156 : _STCONSDEF(_Num_int_base, bool, is_exact)
157 : _STCONSDEF(_Num_int_base, bool, is_integer)
158 : _STCONSDEF(_Num_int_base, bool, is_modulo)
159 : _STCONSDEF(_Num_int_base, bool, is_specialized)
160 : _STCONSDEF(_Num_int_base, int, radix)
161 :
162 : // STRUCT _Num_float_base
163 : struct _CRTIMP2_PURE _Num_float_base
164 : : public _Num_base
165 : { // base for floating-point types
166 : _STCONS(float_denorm_style, has_denorm, denorm_present);
167 : _STCONS(bool, has_denorm_loss, true);
168 : _STCONS(bool, has_infinity, true);
169 : _STCONS(bool, has_quiet_NaN, true);
170 : _STCONS(bool, has_signaling_NaN, true);
171 : _STCONS(bool, is_bounded, true);
172 : _STCONS(bool, is_exact, false);
173 : _STCONS(bool, is_iec559, true);
174 : _STCONS(bool, is_integer, false);
175 : _STCONS(bool, is_modulo, false);
176 : _STCONS(bool, is_signed, true);
177 : _STCONS(bool, is_specialized, true);
178 : _STCONS(bool, tinyness_before, true);
179 : _STCONS(bool, traps, true);
180 : _STCONS(float_round_style, round_style, round_to_nearest);
181 : _STCONS(int, radix, FLT_RADIX);
182 : };
183 :
184 : _STCONSDEF(_Num_float_base, float_denorm_style, has_denorm)
185 : _STCONSDEF(_Num_float_base, bool, has_denorm_loss)
186 : _STCONSDEF(_Num_float_base, bool, has_infinity)
187 : _STCONSDEF(_Num_float_base, bool, has_quiet_NaN)
188 : _STCONSDEF(_Num_float_base, bool, has_signaling_NaN)
189 : _STCONSDEF(_Num_float_base, bool, is_bounded)
190 : _STCONSDEF(_Num_float_base, bool, is_exact)
191 : _STCONSDEF(_Num_float_base, bool, is_iec559)
192 : _STCONSDEF(_Num_float_base, bool, is_integer)
193 : _STCONSDEF(_Num_float_base, bool, is_modulo)
194 : _STCONSDEF(_Num_float_base, bool, is_signed)
195 : _STCONSDEF(_Num_float_base, bool, is_specialized)
196 : _STCONSDEF(_Num_float_base, bool, tinyness_before)
197 : _STCONSDEF(_Num_float_base, bool, traps)
198 : _STCONSDEF(_Num_float_base, float_round_style, round_style)
199 : _STCONSDEF(_Num_float_base, int, radix)
200 :
201 : // CLASS numeric_limits<char>
202 : template<> class _CRTIMP2_PURE numeric_limits<char>
203 : : public _Num_int_base
204 : { // limits for type char
205 : public:
206 : typedef char _Ty;
207 :
208 : static _Ty (__CRTDECL min)() _THROW0()
209 : { // return minimum value
210 : return (CHAR_MIN);
211 : }
212 :
213 : static _Ty (__CRTDECL max)() _THROW0()
214 : { // return maximum value
215 : return (CHAR_MAX);
216 : }
217 :
218 : static _Ty __CRTDECL epsilon() _THROW0()
219 : { // return smallest effective increment from 1.0
220 : return (0);
221 : }
222 :
223 : static _Ty __CRTDECL round_error() _THROW0()
224 : { // return largest rounding error
225 : return (0);
226 : }
227 :
228 : static _Ty __CRTDECL denorm_min() _THROW0()
229 : { // return minimum denormalized value
230 : return (0);
231 : }
232 :
233 : static _Ty __CRTDECL infinity() _THROW0()
234 : { // return positive infinity
235 : return (0);
236 : }
237 :
238 : static _Ty __CRTDECL quiet_NaN() _THROW0()
239 : { // return non-signaling NaN
240 : return (0);
241 : }
242 :
243 : static _Ty __CRTDECL signaling_NaN() _THROW0()
244 : { // return signaling NaN
245 : return (0);
246 : }
247 :
248 : _STCONS(bool, is_signed, CHAR_MIN != 0);
249 : _STCONS(int, digits, CHAR_BIT - (CHAR_MIN != 0 ? 1 : 0));
250 : _STCONS(int, digits10, (CHAR_BIT - (CHAR_MIN != 0 ? 1 : 0))
251 : * 301L / 1000);
252 : };
253 :
254 : _STCONSDEF(numeric_limits<char>, bool, is_signed)
255 : _STCONSDEF(numeric_limits<char>, int, digits)
256 : _STCONSDEF(numeric_limits<char>, int, digits10)
257 :
258 : #ifdef _NATIVE_WCHAR_T_DEFINED
259 : // CLASS numeric_limits<wchar_t>
260 : template<> class _CRTIMP2_PURE numeric_limits<wchar_t>
261 : : public _Num_int_base
262 : { // limits for type wchar_t
263 : public:
264 : typedef wchar_t _Ty;
265 :
266 : static _Ty (__CRTDECL min)() _THROW0()
267 : { // return minimum value
268 : return ((_Ty)WCHAR_MIN);
269 : }
270 :
271 : static _Ty (__CRTDECL max)() _THROW0()
272 : { // return maximum value
273 : return ((_Ty)WCHAR_MAX);
274 : }
275 :
276 : static _Ty __CRTDECL epsilon() _THROW0()
277 : { // return smallest effective increment from 1.0
278 : return (0);
279 : }
280 :
281 : static _Ty __CRTDECL round_error() _THROW0()
282 : { // return largest rounding error
283 : return (0);
284 : }
285 :
286 : static _Ty __CRTDECL denorm_min() _THROW0()
287 : { // return minimum denormalized value
288 : return (0);
289 : }
290 :
291 : static _Ty __CRTDECL infinity() _THROW0()
292 : { // return positive infinity
293 : return (0);
294 : }
295 :
296 : static _Ty __CRTDECL quiet_NaN() _THROW0()
297 : { // return non-signaling NaN
298 : return (0);
299 : }
300 :
301 : static _Ty __CRTDECL signaling_NaN() _THROW0()
302 : { // return signaling NaN
303 : return (0);
304 : }
305 :
306 : _STCONS(bool, is_signed, WCHAR_MIN != 0);
307 : _STCONS(int, digits, CHAR_BIT * sizeof (wchar_t)
308 : - (WCHAR_MIN != 0 ? 1 : 0));
309 : _STCONS(int, digits10, (CHAR_BIT * sizeof (wchar_t)
310 : - (WCHAR_MIN != 0 ? 1 : 0)) * 301L / 1000);
311 : };
312 :
313 : _STCONSDEF(numeric_limits<wchar_t>, bool, is_signed)
314 : _STCONSDEF(numeric_limits<wchar_t>, int, digits)
315 : _STCONSDEF(numeric_limits<wchar_t>, int, digits10)
316 : #endif /* _NATIVE_WCHAR_T_DEFINED */
317 :
318 : // CLASS numeric_limits<_Bool>
319 : template<> class _CRTIMP2_PURE numeric_limits<_Bool>
320 : : public _Num_int_base
321 : { // limits for type bool
322 : public:
323 : typedef bool _Ty;
324 :
325 : static _Ty (__CRTDECL min)() _THROW0()
326 : { // return minimum value
327 : return (false);
328 : }
329 :
330 : static _Ty (__CRTDECL max)() _THROW0()
331 : { // return maximum value
332 : return (true);
333 : }
334 :
335 : static _Ty __CRTDECL epsilon() _THROW0()
336 : { // return smallest effective increment from 1.0
337 : return (0);
338 : }
339 :
340 : static _Ty __CRTDECL round_error() _THROW0()
341 : { // return largest rounding error
342 : return (0);
343 : }
344 :
345 : static _Ty __CRTDECL denorm_min() _THROW0()
346 : { // return minimum denormalized value
347 : return (0);
348 : }
349 :
350 : static _Ty __CRTDECL infinity() _THROW0()
351 : { // return positive infinity
352 : return (0);
353 : }
354 :
355 : static _Ty __CRTDECL quiet_NaN() _THROW0()
356 : { // return non-signaling NaN
357 : return (0);
358 : }
359 :
360 : static _Ty __CRTDECL signaling_NaN() _THROW0()
361 : { // return signaling NaN
362 : return (0);
363 : }
364 :
365 : _STCONS(bool, is_modulo, false);
366 : _STCONS(bool, is_signed, false);
367 : _STCONS(int, digits, 1);
368 : _STCONS(int, digits10, 0);
369 : };
370 :
371 : _STCONSDEF(numeric_limits<_Bool>, bool, is_modulo)
372 : _STCONSDEF(numeric_limits<_Bool>, bool, is_signed)
373 : _STCONSDEF(numeric_limits<_Bool>, int, digits)
374 : _STCONSDEF(numeric_limits<_Bool>, int, digits10)
375 :
376 : // CLASS numeric_limits<signed char>
377 : template<> class _CRTIMP2_PURE numeric_limits<signed char>
378 : : public _Num_int_base
379 : { // limits for type signed char
380 : public:
381 : typedef signed char _Ty;
382 :
383 1 : static _Ty (__CRTDECL min)() _THROW0()
384 : { // return minimum value
385 1 : return (SCHAR_MIN);
386 1 : }
387 :
388 1 : static _Ty (__CRTDECL max)() _THROW0()
389 : { // return maximum value
390 1 : return (SCHAR_MAX);
391 1 : }
392 :
393 : static _Ty __CRTDECL epsilon() _THROW0()
394 : { // return smallest effective increment from 1.0
395 : return (0);
396 : }
397 :
398 : static _Ty __CRTDECL round_error() _THROW0()
399 : { // return largest rounding error
400 : return (0);
401 : }
402 :
403 : static _Ty __CRTDECL denorm_min() _THROW0()
404 : { // return minimum denormalized value
405 : return (0);
406 : }
407 :
408 : static _Ty __CRTDECL infinity() _THROW0()
409 : { // return positive infinity
410 : return (0);
411 : }
412 :
413 : static _Ty __CRTDECL quiet_NaN() _THROW0()
414 : { // return non-signaling NaN
415 : return (0);
416 : }
417 :
418 : static _Ty __CRTDECL signaling_NaN() _THROW0()
419 : { // return signaling NaN
420 : return (0);
421 : }
422 :
423 : _STCONS(bool, is_signed, true);
424 : _STCONS(int, digits, CHAR_BIT - 1);
425 : _STCONS(int, digits10, (CHAR_BIT - 1) * 301L / 1000);
426 : };
427 :
428 : _STCONSDEF(numeric_limits<signed char>, bool, is_signed)
429 : _STCONSDEF(numeric_limits<signed char>, int, digits)
430 : _STCONSDEF(numeric_limits<signed char>, int, digits10)
431 :
432 : // CLASS numeric_limits<unsigned char>
433 : template<> class _CRTIMP2_PURE numeric_limits<unsigned char>
434 : : public _Num_int_base
435 : { // limits for type unsigned char
436 : public:
437 : typedef unsigned char _Ty;
438 :
439 1 : static _Ty (__CRTDECL min)() _THROW0()
440 : { // return minimum value
441 1 : return (0);
442 1 : }
443 :
444 2 : static _Ty (__CRTDECL max)() _THROW0()
445 : { // return maximum value
446 2 : return (UCHAR_MAX);
447 2 : }
448 :
449 : static _Ty __CRTDECL epsilon() _THROW0()
450 : { // return smallest effective increment from 1.0
451 : return (0);
452 : }
453 :
454 : static _Ty __CRTDECL round_error() _THROW0()
455 : { // return largest rounding error
456 : return (0);
457 : }
458 :
459 : static _Ty __CRTDECL denorm_min() _THROW0()
460 : { // return minimum denormalized value
461 : return (0);
462 : }
463 :
464 : static _Ty __CRTDECL infinity() _THROW0()
465 : { // return positive infinity
466 : return (0);
467 : }
468 :
469 : static _Ty __CRTDECL quiet_NaN() _THROW0()
470 : { // return non-signaling NaN
471 : return (0);
472 : }
473 :
474 : static _Ty __CRTDECL signaling_NaN() _THROW0()
475 : { // return signaling NaN
476 : return (0);
477 : }
478 :
479 : _STCONS(bool, is_signed, false);
480 : _STCONS(int, digits, CHAR_BIT);
481 : _STCONS(int, digits10, (CHAR_BIT) * 301L / 1000);
482 : };
483 :
484 : _STCONSDEF(numeric_limits<unsigned char>, bool, is_signed)
485 : _STCONSDEF(numeric_limits<unsigned char>, int, digits)
486 : _STCONSDEF(numeric_limits<unsigned char>, int, digits10)
487 :
488 : // CLASS numeric_limits<short>
489 : template<> class _CRTIMP2_PURE numeric_limits<short>
490 : : public _Num_int_base
491 : { // limits for type short
492 : public:
493 : typedef short _Ty;
494 :
495 : static _Ty (__CRTDECL min)() _THROW0()
496 : { // return minimum value
497 : return (SHRT_MIN);
498 : }
499 :
500 : static _Ty (__CRTDECL max)() _THROW0()
501 : { // return maximum value
502 : return (SHRT_MAX);
503 : }
504 :
505 : static _Ty __CRTDECL epsilon() _THROW0()
506 : { // return smallest effective increment from 1.0
507 : return (0);
508 : }
509 :
510 : static _Ty __CRTDECL round_error() _THROW0()
511 : { // return largest rounding error
512 : return (0);
513 : }
514 :
515 : static _Ty __CRTDECL denorm_min() _THROW0()
516 : { // return minimum denormalized value
517 : return (0);
518 : }
519 :
520 : static _Ty __CRTDECL infinity() _THROW0()
521 : { // return positive infinity
522 : return (0);
523 : }
524 :
525 : static _Ty __CRTDECL quiet_NaN() _THROW0()
526 : { // return non-signaling NaN
527 : return (0);
528 : }
529 :
530 : static _Ty __CRTDECL signaling_NaN() _THROW0()
531 : { // return signaling NaN
532 : return (0);
533 : }
534 :
535 : _STCONS(bool, is_signed, true);
536 : _STCONS(int, digits, CHAR_BIT * sizeof (short) - 1);
537 : _STCONS(int, digits10, (CHAR_BIT * sizeof (short) - 1)
538 : * 301L / 1000);
539 : };
540 :
541 : _STCONSDEF(numeric_limits<short>, bool, is_signed)
542 : _STCONSDEF(numeric_limits<short>, int, digits)
543 : _STCONSDEF(numeric_limits<short>, int, digits10)
544 :
545 : // CLASS numeric_limits<unsigned short>
546 : template<> class _CRTIMP2_PURE numeric_limits<unsigned short>
547 : : public _Num_int_base
548 : { // limits for type unsigned short
549 : public:
550 : typedef unsigned short _Ty;
551 :
552 1 : static _Ty (__CRTDECL min)() _THROW0()
553 : { // return minimum value
554 1 : return (0);
555 1 : }
556 :
557 2 : static _Ty (__CRTDECL max)() _THROW0()
558 : { // return maximum value
559 2 : return (USHRT_MAX);
560 2 : }
561 :
562 : static _Ty __CRTDECL epsilon() _THROW0()
563 : { // return smallest effective increment from 1.0
564 : return (0);
565 : }
566 :
567 : static _Ty __CRTDECL round_error() _THROW0()
568 : { // return largest rounding error
569 : return (0);
570 : }
571 :
572 : static _Ty __CRTDECL denorm_min() _THROW0()
573 : { // return minimum denormalized value
574 : return (0);
575 : }
576 :
577 : static _Ty __CRTDECL infinity() _THROW0()
578 : { // return positive infinity
579 : return (0);
580 : }
581 :
582 : static _Ty __CRTDECL quiet_NaN() _THROW0()
583 : { // return non-signaling NaN
584 : return (0);
585 : }
586 :
587 : static _Ty __CRTDECL signaling_NaN() _THROW0()
588 : { // return signaling NaN
589 : return (0);
590 : }
591 :
592 : _STCONS(bool, is_signed, false);
593 : _STCONS(int, digits, CHAR_BIT * sizeof (unsigned short));
594 : _STCONS(int, digits10, (CHAR_BIT * sizeof (unsigned short))
595 : * 301L / 1000);
596 : };
597 :
598 : _STCONSDEF(numeric_limits<unsigned short>, bool, is_signed)
599 : _STCONSDEF(numeric_limits<unsigned short>, int, digits)
600 : _STCONSDEF(numeric_limits<unsigned short>, int, digits10)
601 :
602 : // CLASS numeric_limits<int>
603 : template<> class _CRTIMP2_PURE numeric_limits<int>
604 : : public _Num_int_base
605 : { // limits for type int
606 : public:
607 : typedef int _Ty;
608 :
609 2 : static _Ty (__CRTDECL min)() _THROW0()
610 : { // return minimum value
611 2 : return (INT_MIN);
612 2 : }
613 :
614 2 : static _Ty (__CRTDECL max)() _THROW0()
615 : { // return maximum value
616 2 : return (INT_MAX);
617 2 : }
618 :
619 : static _Ty __CRTDECL epsilon() _THROW0()
620 : { // return smallest effective increment from 1.0
621 : return (0);
622 : }
623 :
624 : static _Ty __CRTDECL round_error() _THROW0()
625 : { // return largest rounding error
626 : return (0);
627 : }
628 :
629 : static _Ty __CRTDECL denorm_min() _THROW0()
630 : { // return minimum denormalized value
631 : return (0);
632 : }
633 :
634 : static _Ty __CRTDECL infinity() _THROW0()
635 : { // return positive infinity
636 : return (0);
637 : }
638 :
639 : static _Ty __CRTDECL quiet_NaN() _THROW0()
640 : { // return non-signaling NaN
641 : return (0);
642 : }
643 :
644 : static _Ty __CRTDECL signaling_NaN() _THROW0()
645 : { // return signaling NaN
646 : return (0);
647 : }
648 :
649 : _STCONS(bool, is_signed, true);
650 : _STCONS(int, digits, CHAR_BIT * sizeof (int) - 1);
651 : _STCONS(int, digits10, (CHAR_BIT * sizeof (int) - 1)
652 : * 301L / 1000);
653 : };
654 :
655 : _STCONSDEF(numeric_limits<int>, bool, is_signed)
656 : _STCONSDEF(numeric_limits<int>, int, digits)
657 : _STCONSDEF(numeric_limits<int>, int, digits10)
658 :
659 : // CLASS numeric_limits<unsigned int>
660 : template<> class _CRTIMP2_PURE numeric_limits<unsigned int>
661 : : public _Num_int_base
662 : { // limits for type unsigned int
663 : public:
664 : typedef unsigned int _Ty;
665 :
666 2 : static _Ty (__CRTDECL min)() _THROW0()
667 : { // return minimum value
668 2 : return (0);
669 2 : }
670 :
671 3 : static _Ty (__CRTDECL max)() _THROW0()
672 : { // return maximum value
673 3 : return (UINT_MAX);
674 3 : }
675 :
676 : static _Ty __CRTDECL epsilon() _THROW0()
677 : { // return smallest effective increment from 1.0
678 : return (0);
679 : }
680 :
681 : static _Ty __CRTDECL round_error() _THROW0()
682 : { // return largest rounding error
683 : return (0);
684 : }
685 :
686 : static _Ty __CRTDECL denorm_min() _THROW0()
687 : { // return minimum denormalized value
688 : return (0);
689 : }
690 :
691 : static _Ty __CRTDECL infinity() _THROW0()
692 : { // return positive infinity
693 : return (0);
694 : }
695 :
696 : static _Ty __CRTDECL quiet_NaN() _THROW0()
697 : { // return non-signaling NaN
698 : return (0);
699 : }
700 :
701 : static _Ty __CRTDECL signaling_NaN() _THROW0()
702 : { // return signaling NaN
703 : return (0);
704 : }
705 :
706 : _STCONS(bool, is_signed, false);
707 : _STCONS(int, digits, CHAR_BIT * sizeof (unsigned int));
708 : _STCONS(int, digits10, (CHAR_BIT * sizeof (unsigned int))
709 : * 301L / 1000);
710 : };
711 :
712 : _STCONSDEF(numeric_limits<unsigned int>, bool, is_signed)
713 : _STCONSDEF(numeric_limits<unsigned int>, int, digits)
714 : _STCONSDEF(numeric_limits<unsigned int>, int, digits10)
715 :
716 : // CLASS numeric_limits<long>
717 : template<> class _CRTIMP2_PURE numeric_limits<long>
718 : : public _Num_int_base
719 : { // limits for type long
720 : public:
721 : typedef long _Ty;
722 :
723 : static _Ty (__CRTDECL min)() _THROW0()
724 : { // return minimum value
725 : return (LONG_MIN);
726 : }
727 :
728 : static _Ty (__CRTDECL max)() _THROW0()
729 : { // return maximum value
730 : return (LONG_MAX);
731 : }
732 :
733 : static _Ty __CRTDECL epsilon() _THROW0()
734 : { // return smallest effective increment from 1.0
735 : return (0);
736 : }
737 :
738 : static _Ty __CRTDECL round_error() _THROW0()
739 : { // return largest rounding error
740 : return (0);
741 : }
742 :
743 : static _Ty __CRTDECL denorm_min() _THROW0()
744 : { // return minimum denormalized value
745 : return (0);
746 : }
747 :
748 : static _Ty __CRTDECL infinity() _THROW0()
749 : { // return positive infinity
750 : return (0);
751 : }
752 :
753 : static _Ty __CRTDECL quiet_NaN() _THROW0()
754 : { // return non-signaling NaN
755 : return (0);
756 : }
757 :
758 : static _Ty __CRTDECL signaling_NaN() _THROW0()
759 : { // return signaling NaN
760 : return (0);
761 : }
762 :
763 : _STCONS(bool, is_signed, true);
764 : _STCONS(int, digits, CHAR_BIT * sizeof (long) - 1);
765 : _STCONS(int, digits10, (CHAR_BIT * sizeof (long) - 1)
766 : * 301L / 1000);
767 : };
768 :
769 : _STCONSDEF(numeric_limits<long>, bool, is_signed)
770 : _STCONSDEF(numeric_limits<long>, int, digits)
771 : _STCONSDEF(numeric_limits<long>, int, digits10)
772 :
773 : // CLASS numeric_limits<unsigned long>
774 : template<> class _CRTIMP2_PURE numeric_limits<unsigned long>
775 : : public _Num_int_base
776 : { // limits for type unsigned long
777 : public:
778 : typedef unsigned long _Ty;
779 :
780 : static _Ty (__CRTDECL min)() _THROW0()
781 : { // return minimum value
782 : return (0);
783 : }
784 :
785 : static _Ty (__CRTDECL max)() _THROW0()
786 : { // return maximum value
787 : return (ULONG_MAX);
788 : }
789 :
790 : static _Ty __CRTDECL epsilon() _THROW0()
791 : { // return smallest effective increment from 1.0
792 : return (0);
793 : }
794 :
795 : static _Ty __CRTDECL round_error() _THROW0()
796 : { // return largest rounding error
797 : return (0);
798 : }
799 :
800 : static _Ty __CRTDECL denorm_min() _THROW0()
801 : { // return minimum denormalized value
802 : return (0);
803 : }
804 :
805 : static _Ty __CRTDECL infinity() _THROW0()
806 : { // return positive infinity
807 : return (0);
808 : }
809 :
810 : static _Ty __CRTDECL quiet_NaN() _THROW0()
811 : { // return non-signaling NaN
812 : return (0);
813 : }
814 :
815 : static _Ty __CRTDECL signaling_NaN() _THROW0()
816 : { // return signaling NaN
817 : return (0);
818 : }
819 :
820 : _STCONS(bool, is_signed, false);
821 : _STCONS(int, digits, CHAR_BIT * sizeof (unsigned long));
822 : _STCONS(int, digits10, (CHAR_BIT * sizeof (unsigned long))
823 : * 301L / 1000);
824 : };
825 :
826 : _STCONSDEF(numeric_limits<unsigned long>, bool, is_signed)
827 : _STCONSDEF(numeric_limits<unsigned long>, int, digits)
828 : _STCONSDEF(numeric_limits<unsigned long>, int, digits10)
829 :
830 : #ifdef _LONGLONG
831 : // CLASS numeric_limits<_LONGLONG>
832 : template<> class _CRTIMP2_PURE numeric_limits<_LONGLONG>
833 : : public _Num_int_base
834 : { // limits for type long long
835 : public:
836 : typedef _LONGLONG _Ty;
837 :
838 : static _Ty (__CRTDECL min)() _THROW0()
839 : { // return minimum value
840 : return (-_LLONG_MAX - _C2);
841 : }
842 :
843 : static _Ty (__CRTDECL max)() _THROW0()
844 : { // return maximum value
845 : return (_LLONG_MAX);
846 : }
847 :
848 : static _Ty __CRTDECL epsilon() _THROW0()
849 : { // return smallest effective increment from 1.0
850 : return (0);
851 : }
852 :
853 : static _Ty __CRTDECL round_error() _THROW0()
854 : { // return largest rounding error
855 : return (0);
856 : }
857 :
858 : static _Ty __CRTDECL denorm_min() _THROW0()
859 : { // return minimum denormalized value
860 : return (0);
861 : }
862 :
863 : static _Ty __CRTDECL infinity() _THROW0()
864 : { // return positive infinity
865 : return (0);
866 : }
867 :
868 : static _Ty __CRTDECL quiet_NaN() _THROW0()
869 : { // return non-signaling NaN
870 : return (0);
871 : }
872 :
873 : static _Ty __CRTDECL signaling_NaN() _THROW0()
874 : { // return signaling NaN
875 : return (0);
876 : }
877 :
878 : _STCONS(bool, is_signed, true);
879 : _STCONS(int, digits, CHAR_BIT * sizeof (_LONGLONG) - 1);
880 : _STCONS(int, digits10, (CHAR_BIT * sizeof (_LONGLONG) - 1)
881 : * 301L / 1000);
882 : };
883 :
884 : _STCONSDEF(numeric_limits<_LONGLONG>, bool, is_signed)
885 : _STCONSDEF(numeric_limits<_LONGLONG>, int, digits)
886 : _STCONSDEF(numeric_limits<_LONGLONG>, int, digits10)
887 :
888 : // CLASS numeric_limits<_ULONGLONG>
889 : template<> class _CRTIMP2_PURE numeric_limits<_ULONGLONG>
890 : : public _Num_int_base
891 : { // limits for type unsigned long long
892 : public:
893 : typedef _ULONGLONG _Ty;
894 :
895 : static _Ty (__CRTDECL min)() _THROW0()
896 : { // return minimum value
897 : return (0);
898 : }
899 :
900 1 : static _Ty (__CRTDECL max)() _THROW0()
901 : { // return maximum value
902 1 : return (_ULLONG_MAX);
903 1 : }
904 :
905 : static _Ty __CRTDECL epsilon() _THROW0()
906 : { // return smallest effective increment from 1.0
907 : return (0);
908 : }
909 :
910 : static _Ty __CRTDECL round_error() _THROW0()
911 : { // return largest rounding error
912 : return (0);
913 : }
914 :
915 : static _Ty __CRTDECL denorm_min() _THROW0()
916 : { // return minimum denormalized value
917 : return (0);
918 : }
919 :
920 : static _Ty __CRTDECL infinity() _THROW0()
921 : { // return positive infinity
922 : return (0);
923 : }
924 :
925 : static _Ty __CRTDECL quiet_NaN() _THROW0()
926 : { // return non-signaling NaN
927 : return (0);
928 : }
929 :
930 : static _Ty __CRTDECL signaling_NaN() _THROW0()
931 : { // return signaling NaN
932 : return (0);
933 : }
934 :
935 : _STCONS(bool, is_signed, false);
936 : _STCONS(int, digits, CHAR_BIT * sizeof (_ULONGLONG));
937 : _STCONS(int, digits10, (CHAR_BIT * sizeof (_ULONGLONG))
938 : * 301L / 1000);
939 : };
940 :
941 : _STCONSDEF(numeric_limits<_ULONGLONG>, bool, is_signed)
942 : _STCONSDEF(numeric_limits<_ULONGLONG>, int, digits)
943 : _STCONSDEF(numeric_limits<_ULONGLONG>, int, digits10)
944 :
945 : #endif /* _LONGLONG */
946 :
947 : // CLASS numeric_limits<float>
948 : template<> class _CRTIMP2_PURE numeric_limits<float>
949 : : public _Num_float_base
950 : { // limits for type float
951 : public:
952 : typedef float _Ty;
953 :
954 : static _Ty (__CRTDECL min)() _THROW0()
955 : { // return minimum value
956 : return (FLT_MIN);
957 : }
958 :
959 : static _Ty (__CRTDECL max)() _THROW0()
960 : { // return maximum value
961 : return (FLT_MAX);
962 : }
963 :
964 : static _Ty __CRTDECL epsilon() _THROW0()
965 : { // return smallest effective increment from 1.0
966 : return (FLT_EPSILON);
967 : }
968 :
969 : static _Ty __CRTDECL round_error() _THROW0()
970 : { // return largest rounding error
971 : return (0.5);
972 : }
973 :
974 : static _Ty __CRTDECL denorm_min() _THROW0()
975 : { // return minimum denormalized value
976 : return (::_FDenorm._Float);
977 : }
978 :
979 : static _Ty __CRTDECL infinity() _THROW0()
980 : { // return positive infinity
981 : return (::_FInf._Float);
982 : }
983 :
984 : static _Ty __CRTDECL quiet_NaN() _THROW0()
985 : { // return non-signaling NaN
986 : return (::_FNan._Float);
987 : }
988 :
989 : static _Ty __CRTDECL signaling_NaN() _THROW0()
990 : { // return signaling NaN
991 : return (::_FSnan._Float);
992 : }
993 :
994 : _STCONS(int, digits, FLT_MANT_DIG);
995 : _STCONS(int, digits10, FLT_DIG);
996 : _STCONS(int, max_exponent, (int)FLT_MAX_EXP);
997 : _STCONS(int, max_exponent10, (int)FLT_MAX_10_EXP);
998 : _STCONS(int, min_exponent, (int)FLT_MIN_EXP);
999 : _STCONS(int, min_exponent10, (int)FLT_MIN_10_EXP);
1000 : };
1001 :
1002 : _STCONSDEF(numeric_limits<float>, int, digits)
1003 : _STCONSDEF(numeric_limits<float>, int, digits10)
1004 : _STCONSDEF(numeric_limits<float>, int, max_exponent)
1005 : _STCONSDEF(numeric_limits<float>, int, max_exponent10)
1006 : _STCONSDEF(numeric_limits<float>, int, min_exponent)
1007 : _STCONSDEF(numeric_limits<float>, int, min_exponent10)
1008 :
1009 : // CLASS numeric_limits<double>
1010 : template<> class _CRTIMP2_PURE numeric_limits<double>
1011 : : public _Num_float_base
1012 : { // limits for type double
1013 : public:
1014 : typedef double _Ty;
1015 :
1016 : static _Ty (__CRTDECL min)() _THROW0()
1017 : { // return minimum value
1018 : return (DBL_MIN);
1019 : }
1020 :
1021 : static _Ty (__CRTDECL max)() _THROW0()
1022 : { // return maximum value
1023 : return (DBL_MAX);
1024 : }
1025 :
1026 : static _Ty __CRTDECL epsilon() _THROW0()
1027 : { // return smallest effective increment from 1.0
1028 : return (DBL_EPSILON);
1029 : }
1030 :
1031 : static _Ty __CRTDECL round_error() _THROW0()
1032 : { // return largest rounding error
1033 : return (0.5);
1034 : }
1035 :
1036 : static _Ty __CRTDECL denorm_min() _THROW0()
1037 : { // return minimum denormalized value
1038 : return (::_Denorm._Double);
1039 : }
1040 :
1041 : static _Ty __CRTDECL infinity() _THROW0()
1042 : { // return positive infinity
1043 : return (::_Inf._Double);
1044 : }
1045 :
1046 : static _Ty __CRTDECL quiet_NaN() _THROW0()
1047 : { // return non-signaling NaN
1048 : return (::_Nan._Double);
1049 : }
1050 :
1051 : static _Ty __CRTDECL signaling_NaN() _THROW0()
1052 : { // return signaling NaN
1053 : return (::_Snan._Double);
1054 : }
1055 :
1056 : _STCONS(int, digits, DBL_MANT_DIG);
1057 : _STCONS(int, digits10, DBL_DIG);
1058 : _STCONS(int, max_exponent, (int)DBL_MAX_EXP);
1059 : _STCONS(int, max_exponent10, (int)DBL_MAX_10_EXP);
1060 : _STCONS(int, min_exponent, (int)DBL_MIN_EXP);
1061 : _STCONS(int, min_exponent10, (int)DBL_MIN_10_EXP);
1062 : };
1063 :
1064 : _STCONSDEF(numeric_limits<double>, int, digits)
1065 : _STCONSDEF(numeric_limits<double>, int, digits10)
1066 : _STCONSDEF(numeric_limits<double>, int, max_exponent)
1067 : _STCONSDEF(numeric_limits<double>, int, max_exponent10)
1068 : _STCONSDEF(numeric_limits<double>, int, min_exponent)
1069 : _STCONSDEF(numeric_limits<double>, int, min_exponent10)
1070 :
1071 : // CLASS numeric_limits<long double>
1072 : template<> class _CRTIMP2_PURE numeric_limits<long double>
1073 : : public _Num_float_base
1074 : { // limits for type long double
1075 : public:
1076 : typedef long double _Ty;
1077 :
1078 : static _Ty (__CRTDECL min)() _THROW0()
1079 : { // return minimum value
1080 : return (LDBL_MIN);
1081 : }
1082 :
1083 : static _Ty (__CRTDECL max)() _THROW0()
1084 : { // return maximum value
1085 : return (LDBL_MAX);
1086 : }
1087 :
1088 : static _Ty __CRTDECL epsilon() _THROW0()
1089 : { // return smallest effective increment from 1.0
1090 : return (LDBL_EPSILON);
1091 : }
1092 :
1093 : static _Ty __CRTDECL round_error() _THROW0()
1094 : { // return largest rounding error
1095 : return (0.5);
1096 : }
1097 :
1098 : static _Ty __CRTDECL denorm_min() _THROW0()
1099 : { // return minimum denormalized value
1100 : return (::_LDenorm._Long_double);
1101 : }
1102 :
1103 : static _Ty __CRTDECL infinity() _THROW0()
1104 : { // return positive infinity
1105 : return (::_LInf._Long_double);
1106 : }
1107 :
1108 : static _Ty __CRTDECL quiet_NaN() _THROW0()
1109 : { // return non-signaling NaN
1110 : return (::_LNan._Long_double);
1111 : }
1112 :
1113 : static _Ty __CRTDECL signaling_NaN() _THROW0()
1114 : { // return signaling NaN
1115 : return (::_LSnan._Long_double);
1116 : }
1117 :
1118 : _STCONS(int, digits, LDBL_MANT_DIG);
1119 : _STCONS(int, digits10, LDBL_DIG);
1120 : _STCONS(int, max_exponent, (int)LDBL_MAX_EXP);
1121 : _STCONS(int, max_exponent10, (int)LDBL_MAX_10_EXP);
1122 : _STCONS(int, min_exponent, (int)LDBL_MIN_EXP);
1123 : _STCONS(int, min_exponent10, (int)LDBL_MIN_10_EXP);
1124 : };
1125 :
1126 : _STCONSDEF(numeric_limits<long double>, int, digits)
1127 : _STCONSDEF(numeric_limits<long double>, int, digits10)
1128 : _STCONSDEF(numeric_limits<long double>, int, max_exponent)
1129 : _STCONSDEF(numeric_limits<long double>, int, max_exponent10)
1130 : _STCONSDEF(numeric_limits<long double>, int, min_exponent)
1131 : _STCONSDEF(numeric_limits<long double>, int, min_exponent10)
1132 :
1133 : _STD_END
1134 : #ifdef _MSC_VER
1135 : #pragma warning(pop)
1136 : #pragma pack(pop)
1137 : #endif /* _MSC_VER */
1138 :
1139 : #endif /* RC_INVOKED */
1140 : #endif /* _LIMITS_ */
1141 :
1142 : /*
1143 : * Copyright (c) 1992-2006 by P.J. Plauger. ALL RIGHTS RESERVED.
1144 : * Consult your license regarding permissions and restrictions.
1145 : V5.02:0009 */
|
