]>
Commit | Line | Data |
---|---|---|
d876f532 UD |
1 | #include <stdio.h> |
2 | #include <stdlib.h> | |
3 | #include <math.h> | |
4 | ||
5 | #include "soft-fp.h" | |
6 | #include "single.h" | |
7 | #include "double.h" | |
8 | ||
9 | #include <fpu_control.h> | |
10 | ||
11 | /*======================================================================*/ | |
12 | /* declarations for the functions we are testing */ | |
13 | ||
14 | double __adddf3(double, double); | |
15 | double __subdf3(double, double); | |
16 | double __muldf3(double, double); | |
17 | double __divdf3(double, double); | |
18 | double __negdf2(double); | |
19 | double __sqrtdf2(double); | |
20 | double __negdf3(double a, double dummy) { return __negdf2(a); } | |
21 | double __sqrtdf3(double a, double dummy) { return __sqrtdf2(a); } | |
22 | ||
23 | float __addsf3(float, float); | |
24 | float __subsf3(float, float); | |
25 | float __mulsf3(float, float); | |
26 | float __divsf3(float, float); | |
27 | float __negsf2(float); | |
28 | float __sqrtsf2(float); | |
29 | float __negsf3(float a, float dummy) { return __negsf2(a); } | |
30 | float __sqrtsf3(float a, float dummy) { return __sqrtsf2(a); } | |
31 | ||
32 | int __fixdfsi(double); | |
33 | int __fixsfsi(float); | |
34 | double __floatsidf(int); | |
35 | float __floatsisf(int); | |
36 | double __extendsfdf2(float); | |
37 | float __truncdfsf2(double); | |
38 | ||
39 | int __eqdf2(double, double); | |
40 | int __nedf2(double, double); | |
41 | int __gtdf2(double, double); | |
42 | int __gedf2(double, double); | |
43 | int __ltdf2(double, double); | |
44 | int __ledf2(double, double); | |
45 | ||
46 | int __eqsf2(float, float); | |
47 | int __nesf2(float, float); | |
48 | int __gtsf2(float, float); | |
49 | int __gesf2(float, float); | |
50 | int __ltsf2(float, float); | |
51 | int __lesf2(float, float); | |
52 | ||
53 | /*======================================================================*/ | |
54 | /* definitions for functions we are checking against */ | |
55 | ||
56 | double r_adddf3(double a, double b) { return a + b; } | |
57 | double r_subdf3(double a, double b) { return a - b; } | |
58 | double r_muldf3(double a, double b) { return a * b; } | |
59 | double r_divdf3(double a, double b) { return a / b; } | |
60 | double r_negdf3(double a, double b) { return -a; } | |
61 | double sqrt(double x); | |
62 | double r_sqrtdf3(double a, double b) { return sqrt(a); } | |
63 | ||
64 | float r_addsf3(float a, float b) { return a + b; } | |
65 | float r_subsf3(float a, float b) { return a - b; } | |
66 | float r_mulsf3(float a, float b) { return a * b; } | |
67 | float r_divsf3(float a, float b) { return a / b; } | |
68 | float r_negsf3(float a, float b) { return -a; } | |
69 | float sqrtf(float x); | |
70 | float r_sqrtsf3(float a, float b) { return sqrtf(a); } | |
71 | ||
72 | int r_fixdfsi(double a) { return (int)a; } | |
73 | int r_fixsfsi(float a) { return (int)a; } | |
74 | double r_floatsidf(int a) { return (double)a; } | |
75 | float r_floatsisf(int a) { return (float)a; } | |
76 | double r_extendsfdf2(float a) { return (double)a; } | |
77 | float r_truncdfsf2(double a) { return (float)a; } | |
78 | ||
79 | int r_eqdf2(double a, double b) { return !(a == b); } | |
80 | int r_nedf2(double a, double b) { return a != b; } | |
81 | int r_gtdf2(double a, double b) { return a > b; } | |
82 | int r_gedf2(double a, double b) { return (a >= b) - 1; } | |
83 | int r_ltdf2(double a, double b) { return -(a < b); } | |
84 | int r_ledf2(double a, double b) { return 1 - (a <= b); } | |
85 | ||
86 | int r_eqsf2(float a, float b) { return !(a == b); } | |
87 | int r_nesf2(float a, float b) { return a != b; } | |
88 | int r_gtsf2(float a, float b) { return a > b; } | |
89 | int r_gesf2(float a, float b) { return (a >= b) - 1; } | |
90 | int r_ltsf2(float a, float b) { return -(a < b); } | |
91 | int r_lesf2(float a, float b) { return 1 - (a <= b); } | |
92 | ||
93 | /*======================================================================*/ | |
94 | ||
95 | void print_float(float x) | |
96 | { | |
97 | union _FP_UNION_S ux; | |
98 | ux.flt = x; | |
99 | printf("%-20.8e %X %02X %06lX", | |
100 | x, ux.bits.sign, ux.bits.exp, (unsigned long)ux.bits.frac); | |
101 | } | |
102 | ||
103 | void print_double(double x) | |
104 | { | |
105 | union _FP_UNION_D ux; | |
106 | ux.flt = x; | |
107 | #if _FP_W_TYPE_SIZE < _FP_FRACBITS_D | |
108 | printf("%-30.18e %X %04X %06lX%08lX", | |
109 | x, ux.bits.sign, ux.bits.exp, | |
110 | (unsigned long)ux.bits.frac1, (unsigned long)ux.bits.frac0); | |
111 | #else | |
112 | printf("%-30.18e %X %04X %014lX", | |
113 | x, ux.bits.sign, ux.bits.exp, | |
114 | (unsigned long)ux.bits.frac); | |
115 | #endif | |
116 | } | |
117 | ||
118 | float rand_float(void) | |
119 | { | |
120 | union { | |
121 | union _FP_UNION_S u; | |
122 | int i; | |
123 | } u; | |
124 | ||
125 | u.i = lrand48() << 1; | |
126 | ||
127 | if (u.u.bits.exp == _FP_EXPMAX_S) | |
128 | u.u.bits.exp--; | |
129 | else if (u.u.bits.exp == 0 && u.u.bits.frac != 0) | |
130 | u.u.bits.exp++; | |
131 | ||
132 | return u.u.flt; | |
133 | } | |
134 | ||
135 | ||
136 | double rand_double(void) | |
137 | { | |
138 | union { | |
139 | union _FP_UNION_D u; | |
140 | int i[2]; | |
141 | } u; | |
142 | ||
143 | u.i[0] = lrand48() << 1; | |
144 | u.i[1] = lrand48() << 1; | |
145 | ||
146 | if (u.u.bits.exp == _FP_EXPMAX_D) | |
147 | u.u.bits.exp--; | |
148 | #if _FP_W_TYPE_SIZE < _FP_FRACBITS_D | |
149 | else if (u.u.bits.exp == 0 && !(u.u.bits.frac0 == 0 && u.u.bits.frac1 == 0)) | |
150 | u.u.bits.exp++; | |
151 | #else | |
152 | else if (u.u.bits.exp == 0 && u.u.bits.frac != 0) | |
153 | u.u.bits.exp++; | |
154 | #endif | |
155 | ||
156 | return u.u.flt; | |
157 | } | |
158 | ||
159 | #define NSPECIALS 10 | |
160 | ||
161 | float gen_special_float(int i) | |
162 | { | |
163 | FP_DECL_EX; | |
164 | FP_DECL_S(X); | |
165 | float x; | |
166 | ||
167 | switch (i & ~1) | |
168 | { | |
169 | case 0: | |
170 | X_c = FP_CLS_NAN; X_f = 0x1234; | |
171 | break; | |
172 | case 2: | |
173 | X_c = FP_CLS_NAN; X_f = 0x1; | |
174 | break; | |
175 | case 4: | |
176 | X_c = FP_CLS_INF; | |
177 | break; | |
178 | case 6: | |
179 | X_c = FP_CLS_ZERO; | |
180 | break; | |
181 | case 8: | |
182 | X_c = FP_CLS_NORMAL; X_e = 0; | |
183 | X_f = 0x4321; | |
184 | break; | |
185 | } | |
186 | X_s = (i & 1); | |
187 | ||
188 | FP_PACK_S(x, X); | |
189 | return x; | |
190 | } | |
191 | ||
192 | double gen_special_double(int i) | |
193 | { | |
194 | FP_DECL_EX; | |
195 | FP_DECL_D(X); | |
196 | double x; | |
197 | ||
198 | switch (i & ~1) | |
199 | { | |
200 | case 0: | |
201 | X_c = FP_CLS_NAN; | |
202 | #if _FP_W_TYPE_SIZE < _FP_FRACBITS_D | |
2848b105 | 203 | __FP_FRAC_SET_2(X, _FP_QNANNEGATEDP ? 0 : _FP_QNANBIT_D, 0x1234); |
d876f532 | 204 | #else |
2848b105 | 205 | _FP_FRAC_SET_1(X, (_FP_QNANNEGATEDP ? 0 : _FP_QNANBIT_D) | 0x1234); |
d876f532 UD |
206 | #endif |
207 | break; | |
208 | case 2: | |
209 | X_c = FP_CLS_NAN; | |
210 | #if _FP_W_TYPE_SIZE < _FP_FRACBITS_D | |
2848b105 | 211 | __FP_FRAC_SET_2(X, _FP_QNANNEGATEDP ? 0 : _FP_QNANBIT_D, 0x1); |
d876f532 | 212 | #else |
2848b105 | 213 | _FP_FRAC_SET_1(X, (_FP_QNANNEGATEDP ? 0 : _FP_QNANBIT_D) | 0x1); |
d876f532 UD |
214 | #endif |
215 | break; | |
216 | case 4: | |
217 | X_c = FP_CLS_INF; | |
218 | break; | |
219 | case 6: | |
220 | X_c = FP_CLS_ZERO; | |
221 | break; | |
222 | case 8: | |
223 | X_c = FP_CLS_NORMAL; X_e = 0; | |
224 | #if _FP_W_TYPE_SIZE < _FP_FRACBITS_D | |
225 | __FP_FRAC_SET_2(X, 0, 0x87654321); | |
226 | #else | |
227 | _FP_FRAC_SET_1(X, 0x87654321); | |
228 | #endif | |
229 | break; | |
230 | } | |
231 | X_s = (i & 1); | |
232 | ||
233 | FP_PACK_D(x, X); | |
234 | return x; | |
235 | } | |
236 | ||
237 | float build_float(const char *s, const char *e, const char *f) | |
238 | { | |
239 | union _FP_UNION_S u; | |
240 | ||
241 | u.bits.sign = strtoul(s, 0, 16); | |
242 | u.bits.exp = strtoul(e, 0, 16); | |
243 | u.bits.frac = strtoul(f, 0, 16); | |
244 | ||
245 | return u.flt; | |
246 | } | |
9c84384c | 247 | |
d876f532 UD |
248 | double build_double(const char *s, const char *e, const char *f) |
249 | { | |
250 | union _FP_UNION_D u; | |
251 | ||
252 | u.bits.sign = strtoul(s, 0, 16); | |
253 | u.bits.exp = strtoul(e, 0, 16); | |
254 | #if _FP_W_TYPE_SIZE < _FP_FRACBITS_D | |
255 | { | |
256 | size_t len = strlen(f)+1; | |
257 | char *dup = memcpy(alloca(len), f, len); | |
258 | char *low = dup + len - _FP_W_TYPE_SIZE/4 - 1; | |
259 | ||
260 | u.bits.frac0 = strtoul(low, 0, 16); | |
261 | *low = 0; | |
262 | u.bits.frac1 = strtoul(dup, 0, 16); | |
263 | } | |
264 | #else | |
265 | u.bits.frac = strtoul(f, 0, 16); | |
266 | #endif | |
9c84384c | 267 | |
d876f532 UD |
268 | return u.flt; |
269 | } | |
9c84384c | 270 | |
d876f532 UD |
271 | /*======================================================================*/ |
272 | ||
273 | fpu_control_t fcw0, fcw1; | |
274 | ||
275 | void test_float_arith(float (*tf)(float, float), | |
276 | float (*rf)(float, float), | |
277 | float x, float y) | |
278 | { | |
279 | float tr, rr; | |
280 | rr = (*rf)(x, y); | |
281 | tr = (*tf)(x, y); | |
282 | if (memcmp(&tr, &rr, sizeof(float)) != 0) | |
283 | { | |
284 | fputs("error:\n\tx = ", stdout); print_float(x); | |
285 | fputs("\n\ty = ", stdout); print_float(y); | |
286 | fputs("\n\ttrue = ", stdout); print_float(rr); | |
287 | fputs("\n\tfalse = ", stdout); print_float(tr); | |
288 | putchar('\n'); | |
289 | } | |
290 | } | |
291 | ||
292 | void test_double_arith(double (*tf)(double, double), | |
293 | double (*rf)(double, double), | |
294 | double x, double y) | |
295 | { | |
296 | double tr, rr; | |
297 | #ifdef __i386__ | |
298 | /* Don't worry. Even this does not make it error free | |
299 | on ia32. If the result is denormal, it will not | |
300 | honour the double precision and generate bad results | |
301 | anyway. On the other side, who wants to use ia32 | |
302 | for IEEE math? I don't. */ | |
303 | _FPU_GETCW(fcw0); | |
304 | fcw1 = ((fcw0 & ~_FPU_EXTENDED) | _FPU_DOUBLE); | |
305 | _FPU_SETCW(fcw1); | |
9c84384c | 306 | #endif |
d876f532 UD |
307 | rr = (*rf)(x, y); |
308 | #ifdef __i386__ | |
309 | _FPU_SETCW(fcw0); | |
310 | #endif | |
311 | tr = (*tf)(x, y); | |
312 | if (memcmp(&tr, &rr, sizeof(double)) != 0) | |
313 | { | |
314 | fputs("error:\n\tx = ", stdout); print_double(x); | |
315 | fputs("\n\ty = ", stdout); print_double(y); | |
316 | fputs("\n\ttrue = ", stdout); print_double(rr); | |
317 | fputs("\n\tfalse = ", stdout); print_double(tr); | |
318 | putchar('\n'); | |
319 | } | |
320 | } | |
321 | ||
322 | void test_float_double_conv(float x) | |
323 | { | |
324 | double tr, rr; | |
325 | rr = r_extendsfdf2(x); | |
326 | tr = __extendsfdf2(x); | |
327 | if (memcmp(&tr, &rr, sizeof(double)) != 0) | |
328 | { | |
329 | fputs("error:\n\tx = ", stdout); print_float(x); | |
330 | fputs("\n\ttrue = ", stdout); print_double(rr); | |
331 | fputs("\n\tfalse = ", stdout); print_double(tr); | |
332 | putchar('\n'); | |
333 | } | |
334 | } | |
335 | ||
336 | void test_double_float_conv(double x) | |
337 | { | |
338 | float tr, rr; | |
339 | rr = r_truncdfsf2(x); | |
340 | tr = __truncdfsf2(x); | |
341 | if (memcmp(&tr, &rr, sizeof(float)) != 0) | |
342 | { | |
343 | fputs("error:\n\tx = ", stdout); print_double(x); | |
344 | fputs("\n\ttrue = ", stdout); print_float(rr); | |
345 | fputs("\n\tfalse = ", stdout); print_float(tr); | |
346 | putchar('\n'); | |
347 | } | |
348 | } | |
349 | ||
350 | void test_int_float_conv(int x) | |
351 | { | |
352 | float tr, rr; | |
353 | rr = r_floatsisf(x); | |
354 | tr = __floatsisf(x); | |
355 | if (memcmp(&tr, &rr, sizeof(float)) != 0) | |
356 | { | |
357 | printf("error\n\tx = %d", x); | |
358 | fputs("\n\ttrue = ", stdout); print_float(rr); | |
359 | fputs("\n\tfalse = ", stdout); print_float(tr); | |
360 | putchar('\n'); | |
361 | } | |
362 | } | |
363 | ||
364 | void test_int_double_conv(int x) | |
365 | { | |
366 | double tr, rr; | |
367 | rr = r_floatsidf(x); | |
368 | tr = __floatsidf(x); | |
369 | if (memcmp(&tr, &rr, sizeof(double)) != 0) | |
370 | { | |
371 | printf("error\n\tx = %d", x); | |
372 | fputs("\n\ttrue = ", stdout); print_double(rr); | |
373 | fputs("\n\tfalse = ", stdout); print_double(tr); | |
374 | putchar('\n'); | |
375 | } | |
376 | } | |
377 | ||
378 | void test_float_int_conv(float x) | |
379 | { | |
380 | int tr, rr; | |
381 | rr = r_fixsfsi(x); | |
382 | tr = __fixsfsi(x); | |
383 | if (rr != tr) | |
384 | { | |
385 | fputs("error:\n\tx = ", stdout); print_float(x); | |
386 | printf("\n\ttrue = %d\n\tfalse = %d\n", rr, tr); | |
387 | } | |
388 | } | |
9c84384c | 389 | |
d876f532 UD |
390 | void test_double_int_conv(double x) |
391 | { | |
392 | int tr, rr; | |
393 | rr = r_fixsfsi(x); | |
394 | tr = __fixsfsi(x); | |
395 | if (rr != tr) | |
396 | { | |
397 | fputs("error:\n\tx = ", stdout); print_double(x); | |
398 | printf("\n\ttrue = %d\n\tfalse = %d\n", rr, tr); | |
399 | } | |
400 | } | |
401 | ||
402 | int eq0(int x) { return x == 0; } | |
403 | int ne0(int x) { return x != 0; } | |
404 | int le0(int x) { return x <= 0; } | |
405 | int lt0(int x) { return x < 0; } | |
406 | int ge0(int x) { return x >= 0; } | |
407 | int gt0(int x) { return x > 0; } | |
408 | ||
409 | void test_float_cmp(int (*tf)(float, float), | |
410 | int (*rf)(float, float), | |
411 | int (*cmp0)(int), | |
412 | float x, float y) | |
413 | { | |
414 | int tr, rr; | |
415 | rr = (*rf)(x, y); | |
416 | tr = (*tf)(x, y); | |
417 | if (cmp0(rr) != cmp0(tr)) | |
418 | { | |
419 | fputs("error:\n\tx = ", stdout); print_float(x); | |
420 | fputs("\n\ty = ", stdout); print_float(y); | |
421 | printf("\n\ttrue = %d\n\tfalse = %d\n", rr, tr); | |
422 | } | |
423 | } | |
424 | ||
425 | void test_double_cmp(int (*tf)(double, double), | |
426 | int (*rf)(double, double), | |
427 | int (*cmp0)(int), | |
428 | double x, double y) | |
429 | { | |
430 | int tr, rr; | |
431 | rr = (*rf)(x, y); | |
432 | tr = (*tf)(x, y); | |
433 | if (cmp0(rr) != cmp0(tr)) | |
434 | { | |
435 | fputs("error:\n\tx = ", stdout); print_double(x); | |
436 | fputs("\n\ty = ", stdout); print_double(y); | |
437 | printf("\n\ttrue = %d\n\tfalse = %d\n", rr, tr); | |
438 | } | |
439 | } | |
440 | ||
441 | ||
442 | /*======================================================================*/ | |
443 | ||
444 | ||
445 | int main(int ac, char **av) | |
446 | { | |
447 | #ifdef __alpha__ | |
448 | __ieee_set_fp_control(0); | |
449 | #endif | |
450 | av++, ac--; | |
451 | switch (*(*av)++) | |
452 | { | |
453 | { | |
454 | float (*r)(float, float); | |
455 | float (*t)(float, float); | |
456 | ||
457 | do { | |
458 | case 'a': r = r_addsf3; t = __addsf3; break; | |
459 | case 's': r = r_subsf3; t = __subsf3; break; | |
460 | case 'm': r = r_mulsf3; t = __mulsf3; break; | |
461 | case 'd': r = r_divsf3; t = __divsf3; break; | |
462 | case 'r': r = r_sqrtsf3; t = __sqrtsf3; break; | |
463 | case 'j': r = r_negsf3; t = __negsf3; break; | |
464 | } while (0); | |
465 | ||
466 | switch (*(*av)++) | |
467 | { | |
468 | case 'n': | |
469 | { | |
470 | int count = (ac > 1 ? atoi(av[1]) : 100); | |
471 | while (count--) | |
472 | test_float_arith(t, r, rand_float(), rand_float()); | |
473 | } | |
474 | break; | |
475 | ||
476 | case 's': | |
477 | { | |
478 | int i, j; | |
479 | for (i = 0; i < NSPECIALS; i++) | |
480 | for (j = 0; j < NSPECIALS; j++) | |
481 | test_float_arith(t, r, gen_special_float(i), | |
482 | gen_special_float(j)); | |
483 | } | |
484 | break; | |
485 | ||
486 | case 0: | |
487 | if (ac < 7) abort(); | |
488 | test_float_arith(t, r, build_float(av[1], av[2], av[3]), | |
489 | build_float(av[4], av[5], av[6])); | |
490 | break; | |
491 | } | |
492 | } | |
493 | break; | |
494 | ||
495 | { | |
496 | double (*r)(double, double); | |
497 | double (*t)(double, double); | |
498 | ||
499 | do { | |
500 | case 'A': r = r_adddf3; t = __adddf3; break; | |
501 | case 'S': r = r_subdf3; t = __subdf3; break; | |
502 | case 'M': r = r_muldf3; t = __muldf3; break; | |
503 | case 'D': r = r_divdf3; t = __divdf3; break; | |
504 | case 'R': r = r_sqrtdf3; t = __sqrtdf3; break; | |
505 | case 'J': r = r_negdf3; t = __negdf3; break; | |
506 | } while (0); | |
507 | ||
508 | switch (*(*av)++) | |
509 | { | |
510 | case 'n': | |
511 | { | |
512 | int count = (ac > 1 ? atoi(av[1]) : 100); | |
513 | while (count--) | |
514 | test_double_arith(t, r, rand_double(), rand_double()); | |
515 | } | |
516 | break; | |
517 | ||
518 | case 's': | |
519 | { | |
520 | int i, j; | |
521 | for (i = 0; i < NSPECIALS; i++) | |
522 | for (j = 0; j < NSPECIALS; j++) | |
523 | test_double_arith(t, r, gen_special_double(i), | |
524 | gen_special_double(j)); | |
525 | } | |
526 | break; | |
527 | ||
528 | case 0: | |
529 | if (ac < 7) abort(); | |
530 | test_double_arith(t, r, build_double(av[1], av[2], av[3]), | |
531 | build_double(av[4], av[5], av[6])); | |
532 | break; | |
533 | } | |
534 | } | |
535 | break; | |
536 | ||
537 | case 'c': | |
538 | switch (*(*av)++) | |
539 | { | |
540 | case 'n': | |
541 | { | |
542 | int count = (ac > 1 ? atoi(av[1]) : 100); | |
543 | while (count--) | |
544 | test_float_double_conv(rand_float()); | |
545 | } | |
546 | break; | |
547 | ||
548 | case 's': | |
549 | { | |
550 | int i; | |
551 | for (i = 0; i < NSPECIALS; i++) | |
552 | test_float_double_conv(gen_special_float(i)); | |
553 | } | |
554 | break; | |
555 | ||
556 | case 0: | |
557 | if (ac < 4) abort(); | |
558 | test_float_double_conv(build_float(av[1], av[2], av[3])); | |
559 | break; | |
560 | } | |
561 | break; | |
562 | ||
563 | case 'C': | |
564 | switch (*(*av)++) | |
565 | { | |
566 | case 'n': | |
567 | { | |
568 | int count = (ac > 1 ? atoi(av[1]) : 100); | |
569 | while (count--) | |
570 | test_double_float_conv(rand_double()); | |
571 | } | |
572 | break; | |
573 | ||
574 | case 's': | |
575 | { | |
576 | int i; | |
577 | for (i = 0; i < NSPECIALS; i++) | |
578 | test_double_float_conv(gen_special_double(i)); | |
579 | } | |
580 | break; | |
581 | ||
582 | case 0: | |
583 | if (ac < 4) abort(); | |
584 | test_double_float_conv(build_double(av[1], av[2], av[3])); | |
585 | break; | |
586 | } | |
587 | break; | |
588 | ||
589 | case 'i': | |
590 | switch (*(*av)++) | |
591 | { | |
592 | case 'n': | |
593 | { | |
594 | int count = (ac > 1 ? atoi(av[1]) : 100); | |
595 | while (count--) | |
596 | test_int_float_conv(lrand48() << 1); | |
597 | } | |
598 | break; | |
599 | ||
600 | case 0: | |
601 | if (ac < 2) abort(); | |
602 | test_int_float_conv(strtol(av[1], 0, 0)); | |
603 | break; | |
604 | } | |
605 | break; | |
606 | ||
607 | case 'I': | |
608 | switch (*(*av)++) | |
609 | { | |
610 | case 'n': | |
611 | { | |
612 | int count = (ac > 1 ? atoi(av[1]) : 100); | |
613 | while (count--) | |
614 | test_int_double_conv(lrand48() << 1); | |
615 | } | |
616 | break; | |
617 | ||
618 | case 0: | |
619 | if (ac < 2) abort(); | |
620 | test_int_double_conv(strtol(av[1], 0, 0)); | |
621 | break; | |
622 | } | |
623 | break; | |
624 | ||
625 | case 'f': | |
626 | switch (*(*av)++) | |
627 | { | |
628 | case 'n': | |
629 | { | |
630 | int count = (ac > 1 ? atoi(av[1]) : 100); | |
631 | while (count--) | |
632 | test_float_int_conv(rand_float()); | |
633 | } | |
634 | break; | |
635 | ||
636 | case 's': | |
637 | { | |
638 | int i; | |
639 | for (i = 0; i < NSPECIALS; i++) | |
640 | test_float_int_conv(gen_special_float(i)); | |
641 | } | |
642 | break; | |
643 | ||
644 | case 0: | |
645 | if (ac < 4) abort(); | |
646 | test_float_int_conv(build_float(av[1], av[2], av[3])); | |
647 | break; | |
648 | } | |
649 | break; | |
650 | ||
651 | case 'F': | |
652 | switch (*(*av)++) | |
653 | { | |
654 | case 'n': | |
655 | { | |
656 | int count = (ac > 1 ? atoi(av[1]) : 100); | |
657 | while (count--) | |
658 | test_double_int_conv(rand_double()); | |
659 | } | |
660 | break; | |
661 | ||
662 | case 's': | |
663 | { | |
664 | int i; | |
665 | for (i = 0; i < NSPECIALS; i++) | |
666 | test_double_int_conv(gen_special_double(i)); | |
667 | } | |
668 | break; | |
669 | ||
670 | case 0: | |
671 | if (ac < 4) abort(); | |
672 | test_double_int_conv(build_double(av[1], av[2], av[3])); | |
673 | break; | |
674 | } | |
675 | break; | |
676 | ||
677 | { | |
678 | int (*r)(float, float); | |
679 | int (*t)(float, float); | |
680 | int (*c)(int); | |
681 | ||
682 | do { | |
683 | case 'e': r = r_eqsf2; t = __eqsf2; c = eq0; break; | |
684 | case 'n': r = r_nesf2; t = __nesf2; c = ne0; break; | |
685 | case 'l': | |
686 | switch (*(*av)++) | |
687 | { | |
688 | case 'e': r = r_lesf2; t = __lesf2; c = le0; break; | |
689 | case 't': r = r_ltsf2; t = __ltsf2; c = lt0; break; | |
690 | } | |
691 | break; | |
692 | case 'g': | |
693 | switch (*(*av)++) | |
694 | { | |
695 | case 'e': r = r_gesf2; t = __gesf2; c = ge0; break; | |
696 | case 't': r = r_gtsf2; t = __gtsf2; c = gt0; break; | |
697 | } | |
698 | break; | |
699 | } while (0); | |
700 | ||
701 | switch (*(*av)++) | |
702 | { | |
703 | case 'n': | |
704 | { | |
705 | int count = (ac > 1 ? atoi(av[1]) : 100); | |
706 | while (count--) | |
707 | test_float_cmp(t, r, c, rand_float(), rand_float()); | |
708 | } | |
709 | break; | |
710 | ||
711 | case 's': | |
712 | { | |
713 | int i, j; | |
714 | for (i = 0; i < NSPECIALS; i++) | |
715 | for (j = 0; j < NSPECIALS; j++) | |
716 | test_float_cmp(t, r, c, gen_special_float(i), | |
717 | gen_special_float(j)); | |
718 | } | |
719 | break; | |
720 | ||
721 | case 0: | |
722 | if (ac < 7) abort(); | |
723 | test_float_cmp(t, r, c, build_float(av[1], av[2], av[3]), | |
724 | build_float(av[4], av[5], av[6])); | |
725 | break; | |
726 | } | |
727 | } | |
728 | break; | |
729 | ||
730 | { | |
731 | int (*r)(double, double); | |
732 | int (*t)(double, double); | |
733 | int (*c)(int); | |
734 | ||
735 | do { | |
736 | case 'E': r = r_eqdf2; t = __eqdf2; c = eq0; break; | |
737 | case 'N': r = r_nedf2; t = __nedf2; c = ne0; break; | |
738 | case 'L': | |
739 | switch (*(*av)++) | |
740 | { | |
741 | case 'E': r = r_ledf2; t = __ledf2; c = le0; break; | |
742 | case 'T': r = r_ltdf2; t = __ltdf2; c = lt0; break; | |
743 | } | |
744 | break; | |
745 | case 'G': | |
746 | switch (*(*av)++) | |
747 | { | |
748 | case 'E': r = r_gedf2; t = __gedf2; c = ge0; break; | |
749 | case 'T': r = r_gtdf2; t = __gtdf2; c = gt0; break; | |
750 | } | |
751 | break; | |
752 | } while (0); | |
753 | ||
754 | switch (*(*av)++) | |
755 | { | |
756 | case 'n': | |
757 | { | |
758 | int count = (ac > 1 ? atoi(av[1]) : 100); | |
759 | while (count--) | |
760 | test_double_cmp(t, r, c, rand_double(), rand_double()); | |
761 | } | |
762 | break; | |
763 | ||
764 | case 's': | |
765 | { | |
766 | int i, j; | |
767 | for (i = 0; i < NSPECIALS; i++) | |
768 | for (j = 0; j < NSPECIALS; j++) | |
769 | test_double_cmp(t, r, c, gen_special_double(i), | |
770 | gen_special_double(j)); | |
771 | } | |
772 | break; | |
773 | ||
774 | case 0: | |
775 | if (ac < 7) abort(); | |
776 | test_double_cmp(t, r, c, build_double(av[1], av[2], av[3]), | |
777 | build_double(av[4], av[5], av[6])); | |
778 | break; | |
779 | } | |
780 | } | |
781 | break; | |
782 | ||
783 | default: | |
784 | abort(); | |
785 | } | |
786 | ||
787 | return 0; | |
788 | } |