Ne.app NeANT
The Ne.app NeANT User module of the NeANT distribution.
INFINITY.cpp
Go to the documentation of this file.
1// computing infinity and NaN's
2
3
25#include <stdio.h> // for printf()
26#include <string.h> // for memset()
27
28#include "config.h"
29#include "float_defs.h" // for FLT_MIN, DBL_MIN, LDBL_MIN
30
31
69// determine whether the architecture is little-endian or big-endian
70enum endian { big_endian, little_endian };
71
72static const int endian_test = 1;
73
74static const union {
75 const int *pi;
76 const char *pb;
77} u = { &endian_test };
78
79// adding zero below to work around an edg 2.44 bug (the compiler
80// can't explicitly convert a bool expression to an enumeration)
81static const endian e = endian (0 + !!*u.pb);
82
83
85// print out `size' bytes starting at data prefixed by `text'
86static void print (const char *text, const void *data, unsigned size)
87{
88 printf ("%s { ", text);
89
90 const unsigned char *p = (const unsigned char*)data;
91
92 for (unsigned i = 0; i != size; ++i) {
93 if (p[i])
94 printf ("'\\x%x'", p[i]);
95 else
96 printf ("%d", p[i]);
97 if (i < size - 1)
98 printf (", ");
99 }
100
101 printf (" }\n");
102}
103
104
106union flt_bits
107{
108 char bits [sizeof (float)];
109 float val;
110
111 flt_bits () { memset (bits, 0, sizeof (bits)); }
112};
113
114static float flt_zero ()
115{
116 static float val = 0.0f;
117
118 return val;
119}
120
121static flt_bits flt_infinity ()
122{
123 flt_bits val;
124
125#ifdef _RWSTD_NO_DBL_TRAPS
126
127 val.val = 1.0f / flt_zero ();
128
129 // may need to negate to get a correct result
130 // i86 FP expressions appear to return a negative infinity
131 if (val.val < flt_zero ())
132 val.val = -val.val;
133
134#else // if !defined (_RWSTD_NO_DBL_TRAPS)
135
136 // floating point arithmetic traps
137
138 // assume IEEE 754 floating point format
139
140 if (e == big_endian) {
141 val.bits [0] = '\x7f';
142 val.bits [1] = '\x80';
143 val.bits [2] = '\0';
144 val.bits [3] = '\0';
145 }
146 else {
147 val.bits [0] = '\0';
148 val.bits [1] = '\0';
149 val.bits [2] = '\x80';
150 val.bits [3] = '\x7f';
151 }
152
153#endif // _RWSTD_NO_DBL_TRAPS
154
155 return val;
156}
157
158static flt_bits flt_qnan ()
159{
160 flt_bits val;
161
162#ifdef _RWSTD_NO_DBL_TRAPS
163
164 val.val = flt_zero ();
165
166 val.val /= flt_zero ();
167
168 // val.val can be +qnan or -qnan
169 // clear sign bit
170 if (e == big_endian) {
171 val.bits [0] &= '\x7f';
172 }
173 else {
174 val.bits [sizeof (val.val) - 1] &= '\x7f';
175 }
176
177#else // if !defined (_RWSTD_NO_DBL_TRAPS)
178
179 // floating point arithmetic traps
180
181 // assume IEEE 754 floating point format
182
183 if (e == big_endian) {
184 val.bits [0] = '\x7f';
185 val.bits [1] = '\xc0';
186 val.bits [2] = '\0';
187 val.bits [3] = '\0';
188 }
189 else {
190 val.bits [0] = '\0';
191 val.bits [1] = '\0';
192 val.bits [2] = '\xc0';
193 val.bits [3] = '\x7f';
194 }
195
196#endif // _RWSTD_NO_DBL_TRAPS
197
198 return val;
199}
200
201static flt_bits flt_snan ()
202{
203 flt_bits val;
204
205#ifdef _RWSTD_NO_DBL_TRAPS
206
207 val = flt_infinity ();
208
209# if !defined (__hpux)
210
211 // convert infinity into a signaling NAN (toggle any bit in signifcand)
212 if (e == little_endian) {
213 if (0.0f != val.val)
214 val.bits [0] |= 1;
215 }
216 else {
217 if (0.0f != val.val)
218 val.bits [sizeof (val.val) - 1] |= 1;
219 }
220
221# else // if defined (__hpux)
222
223 // QNAN and SNAN on HP-UX are reversed...
224
225 if (e == little_endian) {
226 if (0.0f != val.val)
227 val.bits [1] = '\xc0';
228 }
229 else {
230 if (0.0f != val.val)
231 val.bits [sizeof val.val - 2] = '\xc0';
232 }
233
234# endif // __hpux
235
236#else // if !defined (_RWSTD_NO_DBL_TRAPS)
237
238 // floating point arithmetic traps
239
240 // assume IEEE 754 floating point format
241
242 if (e == big_endian) {
243 val.bits [0] = '\x7f';
244 val.bits [1] = '\x80';
245 val.bits [2] = '\0';
246 val.bits [3] = '\x01';
247 }
248 else {
249 val.bits [0] = '\x01';
250 val.bits [1] = '\0';
251 val.bits [2] = '\x80';
252 val.bits [3] = '\x7f';
253 }
254
255#endif // _RWSTD_NO_DBL_TRAPS
256
257 return val;
258}
259
260static flt_bits flt_denorm_min ()
261{
262 flt_bits val;
263
264#ifdef _RWSTD_NO_DBL_TRAPS
265
266 // compute denorm min
267 for (volatile float tmp = 1.0f; tmp; tmp /= 2.0f)
268 val.val = tmp;
269
270 if (FLT_MIN <= val.val)
271 val.val = 0.0f;
272
273#else
274
275 // assume IEEE 754 floating point format
276
277 if (e == big_endian) {
278 val.bits [0] = '\0';
279 val.bits [1] = '\0';
280 val.bits [2] = '\0';
281 val.bits [3] = '\x01';
282 }
283 else {
284 val.bits [0] = '\x01';
285 val.bits [1] = '\0';
286 val.bits [2] = '\0';
287 val.bits [3] = '\0';
288 }
289
290#endif // _RWSTD_NO_DBL_TRAPS
291
292 return val;
293}
294
295
297union dbl_bits
298{
299 char bits [sizeof (double)];
300 double val;
301
302 dbl_bits () { memset (bits, 0, sizeof (bits)); }
303};
304
305static float dbl_zero ()
306{
307 static double val = 0.0;
308
309 return val;
310}
311
312static dbl_bits dbl_infinity ()
313{
314 dbl_bits val;
315
316#ifdef _RWSTD_NO_DBL_TRAPS
317
318 val.val = 1.0 / dbl_zero ();
319
320 // may need to negate to get a correct result
321 // i86 FP expressions appear to return a negative infinity
322 if (val.val < dbl_zero ())
323 val.val = -val.val;
324
325#else // if !defined (_RWSTD_NO_DBL_TRAPS)
326
327 // floating point arithmetic traps
328
329 // assume IEEE 754 floating point format
330
331 if (e == big_endian) {
332 val.bits [0] = '\x7f';
333 val.bits [1] = '\xf0';
334 val.bits [2] = '\0';
335 val.bits [3] = '\0';
336 val.bits [4] = '\0';
337 val.bits [5] = '\0';
338 val.bits [6] = '\0';
339 val.bits [7] = '\0';
340 }
341 else {
342 val.bits [0] = '\0';
343 val.bits [1] = '\0';
344 val.bits [2] = '\0';
345 val.bits [3] = '\0';
346 val.bits [4] = '\0';
347 val.bits [5] = '\0';
348 val.bits [6] = '\xf0';
349 val.bits [7] = '\x7f';
350 }
351
352#endif // _RWSTD_NO_DBL_TRAPS
353
354 return val;
355}
356
357static dbl_bits dbl_qnan ()
358{
359 dbl_bits val;
360
361#ifdef _RWSTD_NO_DBL_TRAPS
362
363 val.val = dbl_zero ();
364
365 val.val /= dbl_zero ();
366
367 // val.val can be +qnan or -qnan
368 // clear sign bit
369 if (e == big_endian) {
370 val.bits [0] &= '\x7f';
371 }
372 else {
373 val.bits [sizeof (val.val) - 1] &= '\x7f';
374 }
375
376#else // if !defined (_RWSTD_NO_DBL_TRAPS)
377
378 // floating point arithmetic traps
379
380 // assume IEEE 754 floating point format
381
382 if (e == big_endian) {
383 val.bits [0] = '\x7f';
384 val.bits [1] = '\xf8';
385 val.bits [2] = '\0';
386 val.bits [3] = '\0';
387 val.bits [4] = '\0';
388 val.bits [5] = '\0';
389 val.bits [6] = '\0';
390 val.bits [7] = '\0';
391 }
392 else {
393 val.bits [0] = '\0';
394 val.bits [1] = '\0';
395 val.bits [2] = '\0';
396 val.bits [3] = '\0';
397 val.bits [4] = '\0';
398 val.bits [5] = '\0';
399 val.bits [6] = '\xf8';
400 val.bits [7] = '\x7f';
401 }
402
403#endif // _RWSTD_NO_DBL_TRAPS
404
405 return val;
406}
407
408static dbl_bits dbl_snan ()
409{
410 dbl_bits val;
411
412#ifdef _RWSTD_NO_DBL_TRAPS
413
414 val = dbl_infinity ();
415
416# if !defined (__hpux)
417
418 // convert infinity into a signaling NAN (toggle any bit in signifcand)
419 if (e == little_endian) {
420 if (0.0 != val.val)
421 val.bits [0] |= 1;
422 }
423 else {
424 if (0.0 != val.val)
425 val.bits [sizeof val.val - 1] |= 1;
426 }
427
428# else // if defined (__hpux)
429
430 // QNAN and SNAN on HP-UX are reversed...
431
432 if (e == little_endian) {
433 if (0.0 != val.val)
434 val.bits [1] = '\xf8';
435 }
436 else {
437 if (0.0 != val.val)
438 val.bits [sizeof val.val - 2] = '\xf8';
439 }
440
441# endif // __hpux
442
443#else // if !defined (_RWSTD_NO_DBL_TRAPS)
444
445 // floating point arithmetic traps
446
447 // assume IEEE 754 floating point format
448
449 if (e == big_endian) {
450 val.bits [0] = '\x7f';
451 val.bits [1] = '\xf0';
452 val.bits [2] = '\0';
453 val.bits [3] = '\0';
454 val.bits [4] = '\0';
455 val.bits [5] = '\0';
456 val.bits [6] = '\0';
457 val.bits [7] = '\x01';
458 }
459 else {
460 val.bits [0] = '\x01';
461 val.bits [1] = '\0';
462 val.bits [2] = '\0';
463 val.bits [3] = '\0';
464 val.bits [4] = '\0';
465 val.bits [5] = '\0';
466 val.bits [6] = '\xf0';
467 val.bits [7] = '\x7f';
468 }
469
470#endif // _RWSTD_NO_DBL_TRAPS
471
472 return val;
473}
474
475static dbl_bits dbl_denorm_min ()
476{
477 dbl_bits val;
478
479#ifdef _RWSTD_NO_DBL_TRAPS
480
481 // compute denorm min
482 for (volatile double tmp = 1.0; tmp; tmp /= 2.0)
483 val.val = tmp;
484
485 if (DBL_MIN <= val.val)
486 val.val = 0.0;
487
488#else
489
490 // assume IEEE 754 floating point format
491
492 if (e == big_endian) {
493 val.bits [0] = '\0';
494 val.bits [1] = '\0';
495 val.bits [2] = '\0';
496 val.bits [3] = '\0';
497 val.bits [4] = '\0';
498 val.bits [5] = '\0';
499 val.bits [6] = '\0';
500 val.bits [7] = '\x01';
501 }
502 else {
503 val.bits [0] = '\x01';
504 val.bits [1] = '\0';
505 val.bits [2] = '\0';
506 val.bits [3] = '\0';
507 val.bits [4] = '\0';
508 val.bits [5] = '\0';
509 val.bits [6] = '\0';
510 val.bits [7] = '\0';
511 }
512
513#endif // _RWSTD_NO_DBL_TRAPS
514
515 return val;
516}
517
518
520#ifndef _RWSTD_NO_LONG_DOUBLE
521
522union ldbl_bits
523{
524 char bits [sizeof (long double)];
525 long double val;
526
527 ldbl_bits () { memset (bits, 0, sizeof (bits)); }
528};
529
530static long double ldbl_zero ()
531{
532 static long double val = 0.0L;
533
534 return val;
535}
536
537static ldbl_bits ldbl_infinity ()
538{
539 ldbl_bits val;
540
541#ifdef _RWSTD_NO_DBL_TRAPS
542
543 val.val = 1.0L / ldbl_zero ();
544
545 // may need to negate to get a correct result
546 // i86 FP expressions appear to return a negative infinity
547 if (val.val < ldbl_zero ())
548 val.val = -val.val;
549
550#else // if !defined (_RWSTD_NO_DBL_TRAPS)
551
552 // floating point arithmetic traps
553
554 // assume IEEE 754 floating point format
555
556 if (e == big_endian) {
557 val.bits [ 0] = '\x7f';
558 val.bits [ 1] = '\xff';
559 val.bits [ 2] = '\0';
560 val.bits [ 3] = '\0';
561 val.bits [ 4] = '\0';
562 val.bits [ 5] = '\0';
563 val.bits [ 6] = '\0';
564 val.bits [ 7] = '\0';
565 val.bits [ 8] = '\0';
566 val.bits [ 9] = '\0';
567 val.bits [10] = '\0';
568 val.bits [11] = '\0';
569 val.bits [12] = '\0';
570 val.bits [13] = '\0';
571 val.bits [14] = '\0';
572 val.bits [15] = '\0';
573 }
574 else {
575 val.bits [ 0] = '\0';
576 val.bits [ 1] = '\0';
577 val.bits [ 2] = '\0';
578 val.bits [ 3] = '\0';
579 val.bits [ 4] = '\0';
580 val.bits [ 5] = '\0';
581 val.bits [ 6] = '\0';
582 val.bits [ 7] = '\0';
583 val.bits [ 8] = '\0';
584 val.bits [ 9] = '\0';
585 val.bits [10] = '\0';
586 val.bits [11] = '\0';
587 val.bits [12] = '\0';
588 val.bits [13] = '\0';
589 val.bits [14] = '\xff';
590 val.bits [15] = '\x7f';
591 }
592
593#endif // _RWSTD_NO_DBL_TRAPS
594
595 return val;
596}
597
598static ldbl_bits ldbl_qnan ()
599{
600 ldbl_bits val;
601
602#ifdef _RWSTD_NO_DBL_TRAPS
603
604 val.val = ldbl_zero ();
605
606 val.val /= ldbl_zero ();
607
608 // val.val can be +qnan or -qnan
609 // clear sign bit
610 if (e == big_endian) {
611 val.bits [0] &= '\x7f';
612 }
613 else {
614 unsigned inx = sizeof (val.val) - 1;
615 // skip the trailing zero's
616 while (!val.bits [inx]) --inx;
617 val.bits [inx] &= '\x7f';
618 }
619
620#else // if !defined (_RWSTD_NO_DBL_TRAPS)
621
622 // floating point arithmetic traps
623
624 // assume IEEE 754 floating point format
625
626 if (e == big_endian) {
627 val.bits [ 0] = '\x7f';
628 val.bits [ 1] = '\xff';
629 val.bits [ 2] = '\x80';
630 val.bits [ 3] = '\0';
631 val.bits [ 4] = '\0';
632 val.bits [ 5] = '\0';
633 val.bits [ 6] = '\0';
634 val.bits [ 7] = '\0';
635 val.bits [ 8] = '\0';
636 val.bits [ 9] = '\0';
637 val.bits [10] = '\0';
638 val.bits [11] = '\0';
639 val.bits [12] = '\0';
640 val.bits [13] = '\0';
641 val.bits [14] = '\0';
642 val.bits [15] = '\0';
643 }
644 else {
645 val.bits [ 0] = '\0';
646 val.bits [ 1] = '\0';
647 val.bits [ 2] = '\0';
648 val.bits [ 3] = '\0';
649 val.bits [ 4] = '\0';
650 val.bits [ 5] = '\0';
651 val.bits [ 6] = '\0';
652 val.bits [ 7] = '\0';
653 val.bits [ 8] = '\0';
654 val.bits [ 9] = '\0';
655 val.bits [10] = '\0';
656 val.bits [11] = '\0';
657 val.bits [12] = '\0';
658 val.bits [13] = '\x80';
659 val.bits [14] = '\xff';
660 val.bits [15] = '\x7f';
661 }
662
663#endif // _RWSTD_NO_DBL_TRAPS
664
665 return val;
666}
667
668static ldbl_bits ldbl_snan ()
669{
670 ldbl_bits val;
671
672#ifdef _RWSTD_NO_DBL_TRAPS
673
674 val = ldbl_infinity ();
675
676# if !defined (__hpux)
677
678 // convert infinity into a signaling NAN (toggle any bit in signifcand)
679 if (e == little_endian) {
680 if (0.0L != val.val)
681 val.bits [0] |= 1;
682 }
683 else {
684 if (0.0L != val.val)
685 val.bits [sizeof val.val - 1] |= 1;
686 }
687
688# else // if defined (__hpux)
689
690 // QNAN and SNAN on HP-UX are reversed...
691 if (e == little_endian) {
692 if (0.0L != val.val)
693 val.bits [2] = '\x80';
694 }
695 else {
696 if (0.0L != val.val)
697 val.bits [sizeof val.val - 3] = '\x80';
698 }
699
700# endif // __hpux
701
702#else // if !defined (_RWSTD_NO_DBL_TRAPS)
703
704 // floating point arithmetic traps
705
706 // assume IEEE 754 floating point format
707
708 if (e == big_endian) {
709 val.bits [ 0] = '\x7f';
710 val.bits [ 1] = '\xff';
711 val.bits [ 2] = '\0';
712 val.bits [ 3] = '\0';
713 val.bits [ 4] = '\0';
714 val.bits [ 5] = '\0';
715 val.bits [ 6] = '\0';
716 val.bits [ 7] = '\0';
717 val.bits [ 8] = '\0';
718 val.bits [ 9] = '\0';
719 val.bits [10] = '\0';
720 val.bits [11] = '\0';
721 val.bits [12] = '\0';
722 val.bits [13] = '\0';
723 val.bits [14] = '\0';
724 val.bits [15] = '\x01';
725 }
726 else {
727 val.bits [ 0] = '\x01';
728 val.bits [ 1] = '\0';
729 val.bits [ 2] = '\0';
730 val.bits [ 3] = '\0';
731 val.bits [ 4] = '\0';
732 val.bits [ 5] = '\0';
733 val.bits [ 6] = '\0';
734 val.bits [ 7] = '\0';
735 val.bits [ 8] = '\0';
736 val.bits [ 9] = '\0';
737 val.bits [10] = '\0';
738 val.bits [11] = '\0';
739 val.bits [12] = '\0';
740 val.bits [13] = '\0';
741 val.bits [14] = '\xff';
742 val.bits [15] = '\x7f';
743 }
744
745#endif // _RWSTD_NO_DBL_TRAPS
746
747 return val;
748}
749
750static ldbl_bits ldbl_denorm_min ()
751{
752 ldbl_bits val;
753
754#ifdef _RWSTD_NO_DBL_TRAPS
755
756 // compute denorm min
757 for (volatile long double tmp = 1.0L; tmp; tmp /= 2.0L)
758 val.val = tmp;
759
760 if (DBL_MIN < val.val)
761 val.val = DBL_MIN;
762
763#else
764
765 // assume IEEE 754 floating point format
766
767 if (e == big_endian) {
768 val.bits [ 0] = '\0';
769 val.bits [ 1] = '\0';
770 val.bits [ 2] = '\0';
771 val.bits [ 3] = '\0';
772 val.bits [ 4] = '\0';
773 val.bits [ 5] = '\0';
774 val.bits [ 6] = '\0';
775 val.bits [ 7] = '\0';
776 val.bits [ 8] = '\0';
777 val.bits [ 9] = '\0';
778 val.bits [10] = '\0';
779 val.bits [11] = '\0';
780 val.bits [12] = '\0';
781 val.bits [13] = '\0';
782 val.bits [14] = '\0';
783 val.bits [15] = '\x01';
784 }
785 else {
786 val.bits [ 0] = '\x01';
787 val.bits [ 1] = '\0';
788 val.bits [ 2] = '\0';
789 val.bits [ 3] = '\0';
790 val.bits [ 4] = '\0';
791 val.bits [ 5] = '\0';
792 val.bits [ 6] = '\0';
793 val.bits [ 7] = '\0';
794 val.bits [ 8] = '\0';
795 val.bits [ 9] = '\0';
796 val.bits [10] = '\0';
797 val.bits [11] = '\0';
798 val.bits [12] = '\0';
799 val.bits [13] = '\0';
800 val.bits [14] = '\0';
801 val.bits [15] = '\0';
802 }
803
804#endif // _RWSTD_NO_DBL_TRAPS
805
806 return val;
807}
808
809#endif // _RWSTD_NO_LONG_DOUBLE
810
811
813int main ()
814{
815 const flt_bits f_inf = flt_infinity ();
816 const flt_bits f_qnan = flt_qnan ();
817 const flt_bits f_snan = flt_snan ();
818 const flt_bits f_den = flt_denorm_min ();
819
820 const dbl_bits d_inf = dbl_infinity ();
821 const dbl_bits d_qnan = dbl_qnan ();
822 const dbl_bits d_snan = dbl_snan ();
823 const dbl_bits d_den = dbl_denorm_min ();
824
825#ifndef _RWSTD_NO_LONG_DOUBLE
826
827 const ldbl_bits l_inf = ldbl_infinity ();
828 const ldbl_bits l_qnan = ldbl_qnan ();
829 const ldbl_bits l_snan = ldbl_snan ();
830 const ldbl_bits l_den = ldbl_denorm_min ();
831
832#endif // _RWSTD_NO_LONG_DOUBLE
833
834
835#ifdef _RWSTD_NO_DBL_TRAPS
836
837 printf ("// computed infinities and NANs for a %s endian architecture\n",
838 e == big_endian ? "big" : "little");
839
840 const int flt_has_denorm = 0.0f != f_den.val;
841 const int dbl_has_denorm = 0.0 != d_den.val;
842
843# ifndef _RWSTD_NO_LONG_DOUBLE
844
845 const int ldbl_has_denorm = 0.0L != l_den.val;
846
847# endif // _RWSTD_NO_LONG_DOUBLE
848
849#else // if !defined (_RWSTD_NO_DBL_TRAPS)
850
851 printf ("// IEEE 754 infinities and NANs for a %s endian architecture\n"
852 "// (values not computed due to floating exception trapping)\n",
853 e == big_endian ? "big" : "little");
854
855 const int flt_has_denorm = 1;
856 const int dbl_has_denorm = 1;
857 const int ldbl_has_denorm = 1;
858
859#endif // _RWSTD_NO_DBL_TRAPS
860
861 print ("#define _RWSTD_FLT_INF_BITS ", &f_inf, sizeof f_inf);
862 print ("#define _RWSTD_FLT_QNAN_BITS ", &f_qnan, sizeof f_qnan);
863 print ("#define _RWSTD_FLT_SNAN_BITS ", &f_snan, sizeof f_snan);
864 print ("#define _RWSTD_FLT_DENORM_MIN_BITS ", &f_den, sizeof f_den);
865
866 printf ("#define _RWSTD_FLT_HAS_DENORM %d\n", flt_has_denorm);
867
868 print ("#define _RWSTD_DBL_INF_BITS ", &d_inf, sizeof d_inf);
869 print ("#define _RWSTD_DBL_QNAN_BITS ", &d_qnan, sizeof d_qnan);
870 print ("#define _RWSTD_DBL_SNAN_BITS ", &d_snan, sizeof d_snan);
871 print ("#define _RWSTD_DBL_DENORM_MIN_BITS ", &d_den, sizeof d_den);
872
873 printf ("#define _RWSTD_DBL_HAS_DENORM %d\n", dbl_has_denorm);
874
875#ifndef _RWSTD_NO_LONG_DOUBLE
876
877 print ("#define _RWSTD_LDBL_INF_BITS ", &l_inf, sizeof l_inf);
878 print ("#define _RWSTD_LDBL_QNAN_BITS ", &l_qnan, sizeof l_qnan);
879 print ("#define _RWSTD_LDBL_SNAN_BITS ", &l_snan, sizeof l_snan);
880 print ("#define _RWSTD_LDBL_DENORM_MIN_BITS ", &l_den, sizeof l_den);
881
882 printf ("#define _RWSTD_LDBL_HAS_DENORM %d\n", ldbl_has_denorm);
883
884#endif // _RWSTD_NO_LONG_DOUBLE
885
886 return 0;
887}
print
const char print[]
i
#define i
Definition 17.names.cpp:126
u
#define u
Definition 17.names.cpp:137
e
#define e
Definition 17.names.cpp:118
tmp
#define tmp
Definition 17.names.cpp:553
inx
#define inx
Definition 17.names.cpp:484
val
#define val
Definition 17.names.cpp:570
p
#define p
Definition 17.names.cpp:132
flt_zero
volatile float flt_zero
Definition 18.numeric.special.float.cpp:72
dbl_zero
volatile double dbl_zero
Definition 18.numeric.special.float.cpp:73
ldbl_zero
volatile long double ldbl_zero
Definition 18.numeric.special.float.cpp:77
data
const char *const data[]
Definition 21.string.cons.mt.cpp:44
printf
IMPORT_C SInt32 printf(const Char *,...)
endian
endian
Definition INFINITY.cpp:70
big_endian
@ big_endian
Definition INFINITY.cpp:70
little_endian
@ little_endian
Definition INFINITY.cpp:70
main
int main()
Definition INFINITY.cpp:813
size
int size
Definition TEMPLATE_ON_RETURN_TYPE.cpp:45
FLT_MIN
#define FLT_MIN
Definition _cfloat.h:47
DBL_MIN
#define DBL_MIN
Definition _cfloat.h:57
float_defs.h
dbl_bits
Definition INFINITY.cpp:298
dbl_bits::val
double val
Definition INFINITY.cpp:300
dbl_bits::bits
char bits[sizeof(double)]
Definition INFINITY.cpp:299
dbl_bits::dbl_bits
dbl_bits()
Definition INFINITY.cpp:302
flt_bits
Definition INFINITY.cpp:107
flt_bits::flt_bits
flt_bits()
Definition INFINITY.cpp:111
flt_bits::val
float val
Definition INFINITY.cpp:109
flt_bits::bits
char bits[sizeof(float)]
Definition INFINITY.cpp:108
ldbl_bits
Definition INFINITY.cpp:523
ldbl_bits::bits
char bits[sizeof(long double)]
Definition INFINITY.cpp:524
ldbl_bits::ldbl_bits
ldbl_bits()
Definition INFINITY.cpp:527
ldbl_bits::val
long double val
Definition INFINITY.cpp:525
Generated by doxygen 1.9.8