1 : /* Test of isfinite() substitute.
2 : Copyright (C) 2007-2008 Free Software Foundation, Inc.
3 :
4 : This program is free software: you can redistribute it and/or modify
5 : it under the terms of the GNU General Public License as published by
6 : the Free Software Foundation; either version 3 of the License, or
7 : (at your option) any later version.
8 :
9 : This program is distributed in the hope that it will be useful,
10 : but WITHOUT ANY WARRANTY; without even the implied warranty of
11 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 : GNU General Public License for more details.
13 :
14 : You should have received a copy of the GNU General Public License
15 : along with this program. If not, see <http://www.gnu.org/licenses/>. */
16 :
17 : /* Written by Ben Pfaff, 2007, using Bruno Haible's code as a
18 : template. */
19 :
20 : #include <config.h>
21 :
22 : #include <float.h>
23 : #include <limits.h>
24 : #include <math.h>
25 :
26 : #include <stdio.h>
27 : #include <stdlib.h>
28 :
29 : #define ASSERT(expr) \
30 : do \
31 : { \
32 : if (!(expr)) \
33 : { \
34 : fprintf (stderr, "%s:%d: assertion failed\n", __FILE__, __LINE__); \
35 : fflush (stderr); \
36 : abort (); \
37 : } \
38 : } \
39 : while (0)
40 :
41 : float zerof = 0.0f;
42 : double zerod = 0.0;
43 : long double zerol = 0.0L;
44 :
45 : static void
46 : test_isfinitef ()
47 1 : {
48 : /* Zero. */
49 1 : ASSERT (isfinite (0.0f));
50 : /* Subnormal values. */
51 1 : ASSERT (isfinite (FLT_MIN / 2));
52 1 : ASSERT (isfinite (-FLT_MIN / 2));
53 : /* Finite values. */
54 1 : ASSERT (isfinite (3.141f));
55 1 : ASSERT (isfinite (3.141e30f));
56 1 : ASSERT (isfinite (3.141e-30f));
57 1 : ASSERT (isfinite (-2.718f));
58 1 : ASSERT (isfinite (-2.718e30f));
59 1 : ASSERT (isfinite (-2.718e-30f));
60 : /* Infinite values. */
61 1 : ASSERT (!isfinite (1.0f / 0.0f));
62 1 : ASSERT (!isfinite (-1.0f / 0.0f));
63 : /* Quiet NaN. */
64 1 : ASSERT (!isfinite (zerof / zerof));
65 : #if defined FLT_EXPBIT0_WORD && defined FLT_EXPBIT0_BIT
66 : /* Signalling NaN. */
67 : {
68 : #define NWORDS \
69 : ((sizeof (float) + sizeof (unsigned int) - 1) / sizeof (unsigned int))
70 : typedef union { float value; unsigned int word[NWORDS]; } memory_float;
71 : memory_float m;
72 1 : m.value = zerof / zerof;
73 : # if FLT_EXPBIT0_BIT > 0
74 1 : m.word[FLT_EXPBIT0_WORD] ^= (unsigned int) 1 << (FLT_EXPBIT0_BIT - 1);
75 : # else
76 : m.word[FLT_EXPBIT0_WORD + (FLT_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)]
77 : ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1);
78 : # endif
79 : if (FLT_EXPBIT0_WORD < NWORDS / 2)
80 : m.word[FLT_EXPBIT0_WORD + 1] |= (unsigned int) 1 << FLT_EXPBIT0_BIT;
81 : else
82 1 : m.word[0] |= (unsigned int) 1;
83 1 : ASSERT (!isfinite (m.value));
84 : #undef NWORDS
85 : }
86 : #endif
87 1 : }
88 :
89 : static void
90 : test_isfinited ()
91 1 : {
92 : /* Zero. */
93 1 : ASSERT (isfinite (0.0));
94 : /* Subnormal values. */
95 1 : ASSERT (isfinite (DBL_MIN / 2));
96 1 : ASSERT (isfinite (-DBL_MIN / 2));
97 : /* Finite values. */
98 1 : ASSERT (isfinite (3.141));
99 1 : ASSERT (isfinite (3.141e30));
100 1 : ASSERT (isfinite (3.141e-30));
101 1 : ASSERT (isfinite (-2.718));
102 1 : ASSERT (isfinite (-2.718e30));
103 1 : ASSERT (isfinite (-2.718e-30));
104 : /* Infinite values. */
105 1 : ASSERT (!isfinite (1.0 / 0.0));
106 1 : ASSERT (!isfinite (-1.0 / 0.0));
107 : /* Quiet NaN. */
108 1 : ASSERT (!isfinite (zerod / zerod));
109 : #if defined DBL_EXPBIT0_WORD && defined DBL_EXPBIT0_BIT
110 : /* Signalling NaN. */
111 : {
112 : #define NWORDS \
113 : ((sizeof (double) + sizeof (unsigned int) - 1) / sizeof (unsigned int))
114 : typedef union { double value; unsigned int word[NWORDS]; } memory_double;
115 : memory_double m;
116 1 : m.value = zerod / zerod;
117 : # if DBL_EXPBIT0_BIT > 0
118 1 : m.word[DBL_EXPBIT0_WORD] ^= (unsigned int) 1 << (DBL_EXPBIT0_BIT - 1);
119 : # else
120 : m.word[DBL_EXPBIT0_WORD + (DBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)]
121 : ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1);
122 : # endif
123 1 : m.word[DBL_EXPBIT0_WORD + (DBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)]
124 : |= (unsigned int) 1 << DBL_EXPBIT0_BIT;
125 1 : ASSERT (!isfinite (m.value));
126 : #undef NWORDS
127 : }
128 : #endif
129 1 : }
130 :
131 : static void
132 : test_isfinitel ()
133 1 : {
134 : #define NWORDS \
135 : ((sizeof (long double) + sizeof (unsigned int) - 1) / sizeof (unsigned int))
136 : typedef union { unsigned int word[NWORDS]; long double value; }
137 : memory_long_double;
138 :
139 : /* Zero. */
140 1 : ASSERT (isfinite (0.0L));
141 : /* Subnormal values. */
142 1 : ASSERT (isfinite (LDBL_MIN / 2));
143 1 : ASSERT (isfinite (-LDBL_MIN / 2));
144 : /* Finite values. */
145 1 : ASSERT (isfinite (3.141L));
146 1 : ASSERT (isfinite (3.141e30L));
147 1 : ASSERT (isfinite (3.141e-30L));
148 1 : ASSERT (isfinite (-2.718L));
149 1 : ASSERT (isfinite (-2.718e30L));
150 1 : ASSERT (isfinite (-2.718e-30L));
151 : /* Infinite values. */
152 1 : ASSERT (!isfinite (1.0L / 0.0L));
153 1 : ASSERT (!isfinite (-1.0L / 0.0L));
154 : /* Quiet NaN. */
155 1 : ASSERT (!isfinite (zerol / zerol));
156 :
157 : #if defined LDBL_EXPBIT0_WORD && defined LDBL_EXPBIT0_BIT
158 : /* A bit pattern that is different from a Quiet NaN. With a bit of luck,
159 : it's a Signalling NaN. */
160 : {
161 : memory_long_double m;
162 1 : m.value = zerol / zerol;
163 : # if LDBL_EXPBIT0_BIT > 0
164 : m.word[LDBL_EXPBIT0_WORD] ^= (unsigned int) 1 << (LDBL_EXPBIT0_BIT - 1);
165 : # else
166 1 : m.word[LDBL_EXPBIT0_WORD + (LDBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)]
167 : ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1);
168 : # endif
169 1 : m.word[LDBL_EXPBIT0_WORD + (LDBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)]
170 : |= (unsigned int) 1 << LDBL_EXPBIT0_BIT;
171 1 : ASSERT (!isfinite (m.value));
172 : }
173 : #endif
174 :
175 : #if ((defined __ia64 && LDBL_MANT_DIG == 64) || (defined __x86_64__ || defined __amd64__) || (defined __i386 || defined __i386__ || defined _I386 || defined _M_IX86 || defined _X86_))
176 : /* Representation of an 80-bit 'long double' as an initializer for a sequence
177 : of 'unsigned int' words. */
178 : # ifdef WORDS_BIGENDIAN
179 : # define LDBL80_WORDS(exponent,manthi,mantlo) \
180 : { ((unsigned int) (exponent) << 16) | ((unsigned int) (manthi) >> 16), \
181 : ((unsigned int) (manthi) << 16) | (unsigned int) (mantlo) >> 16), \
182 : (unsigned int) (mantlo) << 16 \
183 : }
184 : # else
185 : # define LDBL80_WORDS(exponent,manthi,mantlo) \
186 : { mantlo, manthi, exponent }
187 : # endif
188 : { /* Quiet NaN. */
189 : static memory_long_double x =
190 : { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
191 1 : ASSERT (!isfinite (x.value));
192 : }
193 : {
194 : /* Signalling NaN. */
195 : static memory_long_double x =
196 : { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
197 1 : ASSERT (!isfinite (x.value));
198 : }
199 : /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
200 : Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
201 : Intel IA-64 Architecture Software Developer's Manual, Volume 1:
202 : Application Architecture.
203 : Table 5-2 "Floating-Point Register Encodings"
204 : Figure 5-6 "Memory to Floating-Point Register Data Translation"
205 : */
206 : { /* Pseudo-NaN. */
207 : static memory_long_double x =
208 : { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
209 1 : ASSERT (!isfinite (x.value));
210 : }
211 : { /* Pseudo-Infinity. */
212 : static memory_long_double x =
213 : { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
214 1 : ASSERT (!isfinite (x.value));
215 : }
216 : { /* Pseudo-Zero. */
217 : static memory_long_double x =
218 : { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
219 1 : ASSERT (!isfinite (x.value));
220 : }
221 : { /* Unnormalized number. */
222 : static memory_long_double x =
223 : { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
224 1 : ASSERT (!isfinite (x.value));
225 : }
226 : { /* Pseudo-Denormal. */
227 : static memory_long_double x =
228 : { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
229 1 : ASSERT (!isfinite (x.value));
230 : }
231 : #endif
232 :
233 : #undef NWORDS
234 1 : }
235 :
236 : int
237 : main ()
238 1 : {
239 1 : test_isfinitef ();
240 1 : test_isfinited ();
241 1 : test_isfinitel ();
242 1 : return 0;
243 : }
|
