source: vendor/glibc-tests/2005-06-14/sysdeps/powerpc/test-arith.c

Last change on this file was 2036, checked in by bird, 20 years ago

Initial revision
  • Property cvs2svn:cvs-rev set to 1.1
  • Property svn:eol-style set to native
  • Property svn:executable set to *
  • Property svn:keywords set to Author Date Id Revision
File size: 17.0 KB
Line 
1/* Test floating-point arithmetic operations.
2 Copyright (C) 1997, 1998 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, write to the Free
17 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
18 02111-1307 USA. */
19#ifndef _GNU_SOURCE
20#define _GNU_SOURCE
21#endif
22#include <math.h>
23#include <stdio.h>
24#include <stdlib.h>
25#include <string.h>
26#include <fenv.h>
27#include <assert.h>
28
29#ifndef ESIZE
30typedef double tocheck_t;
31#define ESIZE 11
32#define MSIZE 52
33#define FUNC(x) x
34#endif
35
36#define R_NEAREST 1
37#define R_ZERO 2
38#define R_UP 4
39#define R_DOWN 8
40#define R_ALL (R_NEAREST|R_ZERO|R_UP|R_DOWN)
41static fenv_t rmodes[4];
42static const char * const rmnames[4] =
43{ "nearest","zero","+Inf","-Inf" };
44
45typedef union {
46 tocheck_t tc;
47 unsigned char c[sizeof(tocheck_t)];
48} union_t;
49
50/* Don't try reading these in a font that doesn't distinguish
51 O and zero. */
52typedef enum {
53 P_Z = 0x0, /* 00000...0 */
54 P_000O = 0x1, /* 00011...1 */
55 P_001Z = 0x2, /* 00100...0 */
56 P_00O = 0x3, /* 00111...1 */
57 P_01Z = 0x4, /* 01000...0 */
58 P_010O = 0x5, /* 01011...1 */
59 P_011Z = 0x6, /* 01100...0 */
60 P_0O = 0x7, /* 01111...1 */
61 P_1Z = 0x8, /* 10000...0 */
62 P_100O = 0x9, /* 10011...1 */
63 P_101Z = 0xa, /* 10100...0 */
64 P_10O = 0xb, /* 10111...1 */
65 P_11Z = 0xc, /* 11000...0 */
66 P_110O = 0xd, /* 11011...1 */
67 P_111Z = 0xe, /* 11100...0 */
68 P_O = 0xf, /* 11111...1 */
69 P_Z1 = 0x11, /* 000...001 */
70 P_Z10 = 0x12, /* 000...010 */
71 P_Z11 = 0x13, /* 000...011 */
72 P_0O00 = 0x14, /* 011...100 */
73 P_0O01 = 0x15, /* 011...101 */
74 P_0O0 = 0x16, /* 011...110 */
75 P_1Z1 = 0x19, /* 100...001 */
76 P_1Z10 = 0x1a, /* 100...010 */
77 P_1Z11 = 0x1b, /* 100...011 */
78 P_O00 = 0x1c, /* 111...100 */
79 P_O01 = 0x1d, /* 111...101 */
80 P_O0 = 0x1e, /* 111...110 */
81 P_R = 0x20, /* rrr...rrr */ /* ('r' means random. ) */
82 P_Ro = 0x21, /* rrr...rrr, with odd parity. */
83 P_0R = 0x22, /* 0rr...rrr */
84 P_1R = 0x23, /* 1rr...rrr */
85 P_Rno = 0x24, /* rrr...rrr, but not all ones. */
86} pattern_t;
87
88static void
89pattern_fill(pattern_t ptn, unsigned char *start, int bitoffset, int count)
90{
91#define bitset(count, value) \
92 start[(count)/8] = (start[(count)/8] & ~(1 << 7-(count)%8) \
93 | (value) << 7-(count)%8)
94 int i;
95
96 if (ptn >= 0 && ptn <= 0xf)
97 {
98 /* Patterns between 0 and 0xF have the following format:
99 The LSBit is used to fill the last n-3 bits of the pattern;
100 The next 3 bits are the first 3 bits of the pattern. */
101 for (i = 0; i < count; i++)
102 if (i < 3)
103 bitset((bitoffset+i), ptn >> (3-i) & 1);
104 else
105 bitset((bitoffset+i), ptn >> 0 & 1);
106 }
107 else if (ptn <= 0x1f)
108 {
109 /* Patterns between 0x10 and 0x1F have the following format:
110 The two LSBits are the last two bits of the pattern;
111 The 0x8 bit is the first bit of the pattern;
112 The 0x4 bit is used to fill the remainder. */
113 for (i = 0; i < count; i++)
114 if (i == 0)
115 bitset((bitoffset+i), ptn >> 3 & 1);
116 else if (i >= count-2)
117 bitset((bitoffset+i), ptn >> (count-1-i) & 1);
118 else
119 bitset((bitoffset+i), ptn >> 2 & 1);
120 }
121 else switch (ptn)
122 {
123 case P_0R: case P_1R:
124 assert(count > 0);
125 bitset(bitoffset, ptn & 1);
126 count--;
127 bitoffset++;
128 case P_R:
129 for (; count > 0; count--, bitoffset++)
130 bitset(bitoffset, rand() & 1);
131 break;
132 case P_Ro:
133 {
134 int op = 1;
135 assert(count > 0);
136 for (; count > 1; count--, bitoffset++)
137 bitset(bitoffset, op ^= (rand() & 1));
138 bitset(bitoffset, op);
139 break;
140 }
141 case P_Rno:
142 {
143 int op = 1;
144 assert(count > 0);
145 for (; count > 1; count--, bitoffset++)
146 {
147 int r = rand() & 1;
148 op &= r;
149 bitset(bitoffset, r);
150 }
151 bitset(bitoffset, rand() & (op ^ 1));
152 break;
153 }
154
155 default:
156 assert(0);
157 }
158#undef bitset
159}
160
161static tocheck_t
162pattern(int negative, pattern_t exp, pattern_t mant)
163{
164 union_t result;
165#if 0
166 int i;
167#endif
168
169 pattern_fill(negative ? P_O : P_Z, result.c, 0, 1);
170 pattern_fill(exp, result.c, 1, ESIZE);
171 pattern_fill(mant, result.c, ESIZE+1, MSIZE);
172#if 0
173 printf("neg=%d exp=%02x mant=%02x: ", negative, exp, mant);
174 for (i = 0; i < sizeof(tocheck_t); i++)
175 printf("%02x", result.c[i]);
176 printf("\n");
177#endif
178 return result.tc;
179}
180
181/* Return the closest different tocheck_t to 'x' in the direction of
182 'direction', or 'x' if there is no such value. Assumes 'x' is not
183 a NaN. */
184static tocheck_t
185delta(tocheck_t x, int direction)
186{
187 union_t xx;
188 int i;
189
190 xx.tc = x;
191 if (xx.c[0] & 0x80)
192 direction = -direction;
193 if (direction == +1)
194 {
195 union_t tx;
196 tx.tc = pattern(xx.c[0] >> 7, P_O, P_Z);
197 if (memcmp(tx.c, xx.c, sizeof(tocheck_t)) == 0)
198 return x;
199 }
200 for (i = sizeof(tocheck_t)-1; i > 0; i--)
201 {
202 xx.c[i] += direction;
203 if (xx.c[i] != (direction > 0 ? 0 : 0xff))
204 return xx.tc;
205 }
206 if (direction < 0 && (xx.c[0] & 0x7f) == 0)
207 return pattern(~(xx.c[0] >> 7) & 1, P_Z, P_Z1);
208 else
209 {
210 xx.c[0] += direction;
211 return xx.tc;
212 }
213}
214
215static int nerrors = 0;
216
217#ifdef FE_ALL_INVALID
218static const int all_exceptions = FE_ALL_INVALID | FE_ALL_EXCEPT;
219#else
220static const int all_exceptions = FE_ALL_EXCEPT;
221#endif
222
223static void
224check_result(int line, const char *rm, tocheck_t expected, tocheck_t actual)
225{
226 if (memcmp(&expected, &actual, sizeof(tocheck_t)) != 0)
227 {
228 unsigned char *ex, *ac;
229 size_t i;
230
231 printf("%s:%d:round %s:result failed\n"
232 " expected result 0x", __FILE__, line, rm);
233 ex = (unsigned char *)&expected;
234 ac = (unsigned char *)&actual;
235 for (i = 0; i < sizeof(tocheck_t); i++)
236 printf("%02x", ex[i]);
237 printf(" got 0x");
238 for (i = 0; i < sizeof(tocheck_t); i++)
239 printf("%02x", ac[i]);
240 printf("\n");
241 nerrors++;
242 }
243}
244
245static const struct {
246 int except;
247 const char *name;
248} excepts[] = {
249#define except_entry(ex) { ex, #ex } ,
250#ifdef FE_INEXACT
251 except_entry(FE_INEXACT)
252#else
253# define FE_INEXACT 0
254#endif
255#ifdef FE_DIVBYZERO
256 except_entry(FE_DIVBYZERO)
257#else
258# define FE_DIVBYZERO 0
259#endif
260#ifdef FE_UNDERFLOW
261 except_entry(FE_UNDERFLOW)
262#else
263# define FE_UNDERFLOW 0
264#endif
265#ifdef FE_OVERFLOW
266 except_entry(FE_OVERFLOW)
267#else
268# define FE_OVERFLOW 0
269#endif
270#ifdef FE_INVALID
271 except_entry(FE_INVALID)
272#else
273# define FE_INVALID 0
274#endif
275#ifdef FE_INVALID_SNAN
276 except_entry(FE_INVALID_SNAN)
277#else
278# define FE_INVALID_SNAN FE_INVALID
279#endif
280#ifdef FE_INVALID_ISI
281 except_entry(FE_INVALID_ISI)
282#else
283# define FE_INVALID_ISI FE_INVALID
284#endif
285#ifdef FE_INVALID_IDI
286 except_entry(FE_INVALID_IDI)
287#else
288# define FE_INVALID_IDI FE_INVALID
289#endif
290#ifdef FE_INVALID_ZDZ
291 except_entry(FE_INVALID_ZDZ)
292#else
293# define FE_INVALID_ZDZ FE_INVALID
294#endif
295#ifdef FE_INVALID_COMPARE
296 except_entry(FE_INVALID_COMPARE)
297#else
298# define FE_INVALID_COMPARE FE_INVALID
299#endif
300#ifdef FE_INVALID_SOFTWARE
301 except_entry(FE_INVALID_SOFTWARE)
302#else
303# define FE_INVALID_SOFTWARE FE_INVALID
304#endif
305#ifdef FE_INVALID_SQRT
306 except_entry(FE_INVALID_SQRT)
307#else
308# define FE_INVALID_SQRT FE_INVALID
309#endif
310#ifdef FE_INVALID_INTEGER_CONVERSION
311 except_entry(FE_INVALID_INTEGER_CONVERSION)
312#else
313# define FE_INVALID_INTEGER_CONVERSION FE_INVALID
314#endif
315};
316
317static int excepts_missing = 0;
318
319static void
320check_excepts(int line, const char *rm, int expected, int actual)
321{
322 if (expected & excepts_missing)
323 expected = expected & ~excepts_missing | FE_INVALID_SNAN;
324 if ((expected & all_exceptions) != actual)
325 {
326 size_t i;
327 printf("%s:%d:round %s:exceptions failed\n"
328 " expected exceptions ", __FILE__, line,rm);
329 for (i = 0; i < sizeof(excepts)/sizeof(excepts[0]); i++)
330 if (expected & excepts[i].except)
331 printf("%s ",excepts[i].name);
332 if ((expected & all_exceptions) == 0)
333 printf("- ");
334 printf("got");
335 for (i = 0; i < sizeof(excepts)/sizeof(excepts[0]); i++)
336 if (actual & excepts[i].except)
337 printf(" %s",excepts[i].name);
338 if ((actual & all_exceptions) == 0)
339 printf("- ");
340 printf(".\n");
341 nerrors++;
342 }
343}
344
345typedef enum {
346 B_ADD, B_SUB, B_MUL, B_DIV, B_NEG, B_ABS, B_SQRT
347} op_t;
348typedef struct {
349 int line;
350 op_t op;
351 int a_sgn;
352 pattern_t a_exp, a_mant;
353 int b_sgn;
354 pattern_t b_exp, b_mant;
355 int rmode;
356 int excepts;
357 int x_sgn;
358 pattern_t x_exp, x_mant;
359} optest_t;
360static const optest_t optests[] = {
361 /* Additions of zero. */
362 {__LINE__,B_ADD, 0,P_Z,P_Z, 0,P_Z,P_Z, R_ALL,0, 0,P_Z,P_Z },
363 {__LINE__,B_ADD, 1,P_Z,P_Z, 0,P_Z,P_Z, R_ALL & ~R_DOWN,0, 0,P_Z,P_Z },
364 {__LINE__,B_ADD, 1,P_Z,P_Z, 0,P_Z,P_Z, R_DOWN,0, 1,P_Z,P_Z },
365 {__LINE__,B_ADD, 1,P_Z,P_Z, 1,P_Z,P_Z, R_ALL,0, 1,P_Z,P_Z },
366
367 /* Additions with NaN. */
368 {__LINE__,B_ADD, 0,P_O,P_101Z, 0,P_Z,P_Z, R_ALL,0, 0,P_O,P_101Z },
369 {__LINE__,B_ADD, 0,P_O,P_01Z, 0,P_Z,P_Z, R_ALL,
370 FE_INVALID | FE_INVALID_SNAN, 0,P_O,P_11Z },
371 {__LINE__,B_ADD, 0,P_O,P_Z, 0,P_O,P_0O, R_ALL,
372 FE_INVALID | FE_INVALID_SNAN, 0,P_O,P_O },
373 {__LINE__,B_ADD, 0,P_Z,P_Z, 0,P_O,P_11Z, R_ALL,0, 0,P_O,P_11Z },
374 {__LINE__,B_ADD, 0,P_O,P_001Z, 0,P_O,P_001Z, R_ALL,
375 FE_INVALID | FE_INVALID_SNAN, 0,P_O,P_101Z },
376 {__LINE__,B_ADD, 0,P_O,P_1Z, 0,P_Z,P_Z, R_ALL,0, 0,P_O,P_1Z },
377 {__LINE__,B_ADD, 0,P_0O,P_Z, 0,P_O,P_10O, R_ALL,0, 0,P_O,P_10O },
378
379 /* Additions with infinity. */
380 {__LINE__,B_ADD, 0,P_O,P_Z, 0,P_Z,P_Z, R_ALL,0, 0,P_O,P_Z },
381 {__LINE__,B_ADD, 0,P_O,P_Z, 1,P_Z,P_Z, R_ALL,0, 0,P_O,P_Z },
382 {__LINE__,B_ADD, 1,P_O,P_Z, 0,P_Z,P_Z, R_ALL,0, 1,P_O,P_Z },
383 {__LINE__,B_ADD, 1,P_O,P_Z, 1,P_Z,P_Z, R_ALL,0, 1,P_O,P_Z },
384 {__LINE__,B_ADD, 0,P_O,P_Z, 0,P_O,P_Z, R_ALL,0, 0,P_O,P_Z },
385 {__LINE__,B_ADD, 1,P_O,P_Z, 1,P_O,P_Z, R_ALL,0, 1,P_O,P_Z },
386 {__LINE__,B_ADD, 0,P_O,P_Z, 1,P_O,P_Z, R_ALL,
387 FE_INVALID | FE_INVALID_ISI, 0,P_O,P_1Z },
388 {__LINE__,B_ADD, 1,P_O,P_Z, 0,P_O,P_Z, R_ALL,
389 FE_INVALID | FE_INVALID_ISI, 0,P_O,P_1Z },
390 {__LINE__,B_ADD, 0,P_O,P_Z, 0,P_0O,P_Z, R_ALL,0, 0,P_O,P_Z },
391 {__LINE__,B_ADD, 1,P_O,P_Z, 0,P_0O,P_Z, R_ALL,0, 1,P_O,P_Z },
392 {__LINE__,B_ADD, 0,P_O,P_Z, 1,P_0O,P_Z, R_ALL,0, 0,P_O,P_Z },
393 {__LINE__,B_ADD, 1,P_O,P_Z, 1,P_0O,P_Z, R_ALL,0, 1,P_O,P_Z },
394
395 /* Overflow (and zero). */
396 {__LINE__,B_ADD, 0,P_O0,P_Z, 0,P_O0,P_Z, R_NEAREST | R_UP,
397 FE_INEXACT | FE_OVERFLOW, 0,P_O,P_Z },
398 {__LINE__,B_ADD, 0,P_O0,P_Z, 0,P_O0,P_Z, R_ZERO | R_DOWN,
399 FE_INEXACT | FE_OVERFLOW, 0,P_O0,P_O },
400 {__LINE__,B_ADD, 1,P_O0,P_Z, 1,P_O0,P_Z, R_NEAREST | R_DOWN,
401 FE_INEXACT | FE_OVERFLOW, 1,P_O,P_Z },
402 {__LINE__,B_ADD, 1,P_O0,P_Z, 1,P_O0,P_Z, R_ZERO | R_UP,
403 FE_INEXACT | FE_OVERFLOW, 1,P_O0,P_O },
404 {__LINE__,B_ADD, 0,P_O0,P_Z, 1,P_O0,P_Z, R_ALL & ~R_DOWN,
405 0, 0,P_Z,P_Z },
406 {__LINE__,B_ADD, 0,P_O0,P_Z, 1,P_O0,P_Z, R_DOWN,
407 0, 1,P_Z,P_Z },
408
409 /* Negation. */
410 {__LINE__,B_NEG, 0,P_Z,P_Z, 0,0,0, R_ALL, 0, 1,P_Z,P_Z },
411 {__LINE__,B_NEG, 1,P_Z,P_Z, 0,0,0, R_ALL, 0, 0,P_Z,P_Z },
412 {__LINE__,B_NEG, 0,P_O,P_Z, 0,0,0, R_ALL, 0, 1,P_O,P_Z },
413 {__LINE__,B_NEG, 1,P_O,P_Z, 0,0,0, R_ALL, 0, 0,P_O,P_Z },
414 {__LINE__,B_NEG, 0,P_O,P_1Z, 0,0,0, R_ALL, 0, 1,P_O,P_1Z },
415 {__LINE__,B_NEG, 1,P_O,P_1Z, 0,0,0, R_ALL, 0, 0,P_O,P_1Z },
416 {__LINE__,B_NEG, 0,P_O,P_01Z, 0,0,0, R_ALL, 0, 1,P_O,P_01Z },
417 {__LINE__,B_NEG, 1,P_O,P_01Z, 0,0,0, R_ALL, 0, 0,P_O,P_01Z },
418 {__LINE__,B_NEG, 0,P_1Z,P_1Z1, 0,0,0, R_ALL, 0, 1,P_1Z,P_1Z1 },
419 {__LINE__,B_NEG, 1,P_1Z,P_1Z1, 0,0,0, R_ALL, 0, 0,P_1Z,P_1Z1 },
420 {__LINE__,B_NEG, 0,P_Z,P_Z1, 0,0,0, R_ALL, 0, 1,P_Z,P_Z1 },
421 {__LINE__,B_NEG, 1,P_Z,P_Z1, 0,0,0, R_ALL, 0, 0,P_Z,P_Z1 },
422
423 /* Absolute value. */
424 {__LINE__,B_ABS, 0,P_Z,P_Z, 0,0,0, R_ALL, 0, 0,P_Z,P_Z },
425 {__LINE__,B_ABS, 1,P_Z,P_Z, 0,0,0, R_ALL, 0, 0,P_Z,P_Z },
426 {__LINE__,B_ABS, 0,P_O,P_Z, 0,0,0, R_ALL, 0, 0,P_O,P_Z },
427 {__LINE__,B_ABS, 1,P_O,P_Z, 0,0,0, R_ALL, 0, 0,P_O,P_Z },
428 {__LINE__,B_ABS, 0,P_O,P_1Z, 0,0,0, R_ALL, 0, 0,P_O,P_1Z },
429 {__LINE__,B_ABS, 1,P_O,P_1Z, 0,0,0, R_ALL, 0, 0,P_O,P_1Z },
430 {__LINE__,B_ABS, 0,P_O,P_01Z, 0,0,0, R_ALL, 0, 0,P_O,P_01Z },
431 {__LINE__,B_ABS, 1,P_O,P_01Z, 0,0,0, R_ALL, 0, 0,P_O,P_01Z },
432 {__LINE__,B_ABS, 0,P_1Z,P_1Z1, 0,0,0, R_ALL, 0, 0,P_1Z,P_1Z1 },
433 {__LINE__,B_ABS, 1,P_1Z,P_1Z1, 0,0,0, R_ALL, 0, 0,P_1Z,P_1Z1 },
434 {__LINE__,B_ABS, 0,P_Z,P_Z1, 0,0,0, R_ALL, 0, 0,P_Z,P_Z1 },
435 {__LINE__,B_ABS, 1,P_Z,P_Z1, 0,0,0, R_ALL, 0, 0,P_Z,P_Z1 },
436
437 /* Square root. */
438 {__LINE__,B_SQRT, 0,P_Z,P_Z, 0,0,0, R_ALL, 0, 0,P_Z,P_Z },
439 {__LINE__,B_SQRT, 1,P_Z,P_Z, 0,0,0, R_ALL, 0, 1,P_Z,P_Z },
440 {__LINE__,B_SQRT, 0,P_O,P_1Z, 0,0,0, R_ALL, 0, 0,P_O,P_1Z },
441 {__LINE__,B_SQRT, 1,P_O,P_1Z, 0,0,0, R_ALL, 0, 1,P_O,P_1Z },
442 {__LINE__,B_SQRT, 0,P_O,P_01Z, 0,0,0, R_ALL,
443 FE_INVALID | FE_INVALID_SNAN, 0,P_O,P_11Z },
444 {__LINE__,B_SQRT, 1,P_O,P_01Z, 0,0,0, R_ALL,
445 FE_INVALID | FE_INVALID_SNAN, 1,P_O,P_11Z },
446
447 {__LINE__,B_SQRT, 0,P_O,P_Z, 0,0,0, R_ALL, 0, 0,P_O,P_Z },
448 {__LINE__,B_SQRT, 0,P_0O,P_Z, 0,0,0, R_ALL, 0, 0,P_0O,P_Z },
449
450 {__LINE__,B_SQRT, 1,P_O,P_Z, 0,0,0, R_ALL,
451 FE_INVALID | FE_INVALID_SQRT, 0,P_O,P_1Z },
452 {__LINE__,B_SQRT, 1,P_1Z,P_1Z1, 0,0,0, R_ALL,
453 FE_INVALID | FE_INVALID_SQRT, 0,P_O,P_1Z },
454 {__LINE__,B_SQRT, 1,P_Z,P_Z1, 0,0,0, R_ALL,
455 FE_INVALID | FE_INVALID_SQRT, 0,P_O,P_1Z },
456
457};
458
459static void
460check_op(void)
461{
462 size_t i;
463 int j;
464 tocheck_t r, a, b, x;
465 int raised;
466
467 for (i = 0; i < sizeof(optests)/sizeof(optests[0]); i++)
468 {
469 a = pattern(optests[i].a_sgn, optests[i].a_exp,
470 optests[i].a_mant);
471 b = pattern(optests[i].b_sgn, optests[i].b_exp,
472 optests[i].b_mant);
473 x = pattern(optests[i].x_sgn, optests[i].x_exp,
474 optests[i].x_mant);
475 for (j = 0; j < 4; j++)
476 if (optests[i].rmode & 1<<j)
477 {
478 fesetenv(rmodes+j);
479 switch (optests[i].op)
480 {
481 case B_ADD: r = a + b; break;
482 case B_SUB: r = a - b; break;
483 case B_MUL: r = a * b; break;
484 case B_DIV: r = a / b; break;
485 case B_NEG: r = -a; break;
486 case B_ABS: r = FUNC(fabs)(a); break;
487 case B_SQRT: r = FUNC(sqrt)(a); break;
488 }
489 raised = fetestexcept(all_exceptions);
490 check_result(optests[i].line,rmnames[j],x,r);
491 check_excepts(optests[i].line,rmnames[j],
492 optests[i].excepts,raised);
493 }
494 }
495}
496
497static void
498fail_xr(int line, const char *rm, tocheck_t x, tocheck_t r, tocheck_t xx,
499 int xflag)
500{
501 size_t i;
502 unsigned char *cx, *cr, *cxx;
503
504 printf("%s:%d:round %s:fail\n with x=0x", __FILE__, line,rm);
505 cx = (unsigned char *)&x;
506 cr = (unsigned char *)&r;
507 cxx = (unsigned char *)&xx;
508 for (i = 0; i < sizeof(tocheck_t); i++)
509 printf("%02x", cx[i]);
510 printf(" r=0x");
511 for (i = 0; i < sizeof(tocheck_t); i++)
512 printf("%02x", cr[i]);
513 printf(" xx=0x");
514 for (i = 0; i < sizeof(tocheck_t); i++)
515 printf("%02x", cxx[i]);
516 printf(" inexact=%d\n", xflag != 0);
517 nerrors++;
518}
519
520static void
521check_sqrt(tocheck_t a)
522{
523 int j;
524 tocheck_t r0, r1, r2, x0, x1, x2;
525 int raised = 0;
526 int ok;
527
528 for (j = 0; j < 4; j++)
529 {
530 int excepts;
531
532 fesetenv(rmodes+j);
533 r1 = FUNC(sqrt)(a);
534 excepts = fetestexcept(all_exceptions);
535 fesetenv(FE_DFL_ENV);
536 raised |= excepts & ~FE_INEXACT;
537 x1 = r1 * r1 - a;
538 if (excepts & FE_INEXACT)
539 {
540 r0 = delta(r1,-1); r2 = delta(r1,1);
541 switch (1 << j)
542 {
543 case R_NEAREST:
544 x0 = r0 * r0 - a; x2 = r2 * r2 - a;
545 ok = fabs(x0) >= fabs(x1) && fabs(x1) <= fabs(x2);
546 break;
547 case R_ZERO: case R_DOWN:
548 x2 = r2 * r2 - a;
549 ok = x1 <= 0 && x2 >= 0;
550 break;
551 case R_UP:
552 x0 = r0 * r0 - a;
553 ok = x1 >= 0 && x0 <= 0;
554 break;
555 default:
556 assert(0);
557 }
558 }
559 else
560 ok = x1 == 0;
561 if (!ok)
562 fail_xr(__LINE__,rmnames[j],a,r1,x1,excepts&FE_INEXACT);
563 }
564 check_excepts(__LINE__,"all",0,raised);
565}
566
567int main(int argc, char **argv)
568{
569 int i;
570
571 _LIB_VERSION = _IEEE_;
572
573 /* Set up environments for rounding modes. */
574 fesetenv(FE_DFL_ENV);
575 fesetround(FE_TONEAREST);
576 fegetenv(rmodes+0);
577 fesetround(FE_TOWARDZERO);
578 fegetenv(rmodes+1);
579 fesetround(FE_UPWARD);
580 fegetenv(rmodes+2);
581 fesetround(FE_DOWNWARD);
582 fegetenv(rmodes+3);
583
584#if defined(FE_INVALID_SOFTWARE) || defined(FE_INVALID_SQRT)
585 /* There's this really stupid feature of the 601... */
586 fesetenv(FE_DFL_ENV);
587 feraiseexcept(FE_INVALID_SOFTWARE);
588 if (!fetestexcept(FE_INVALID_SOFTWARE))
589 excepts_missing |= FE_INVALID_SOFTWARE;
590 fesetenv(FE_DFL_ENV);
591 feraiseexcept(FE_INVALID_SQRT);
592 if (!fetestexcept(FE_INVALID_SQRT))
593 excepts_missing |= FE_INVALID_SQRT;
594#endif
595
596 check_op();
597 for (i = 0; i < 100000; i++)
598 check_sqrt(pattern(0, P_Rno, P_R));
599 for (i = 0; i < 100; i++)
600 check_sqrt(pattern(0, P_Z, P_R));
601 check_sqrt(pattern(0,P_Z,P_Z1));
602
603 printf("%d errors.\n", nerrors);
604 return nerrors == 0 ? 0 : 1;
605}
Note: See TracBrowser for help on using the repository browser.