Warning: That file was not part of the compilation database. It may have many parsing errors.

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 |

203 | __FP_FRAC_SET_2(X, _FP_QNANNEGATEDP ? 0 : _FP_QNANBIT_D, 0x1234); |

204 | #else |

205 | _FP_FRAC_SET_1(X, (_FP_QNANNEGATEDP ? 0 : _FP_QNANBIT_D) | 0x1234); |

206 | #endif |

207 | break; |

208 | case 2: |

209 | X_c = FP_CLS_NAN; |

210 | #if _FP_W_TYPE_SIZE < _FP_FRACBITS_D |

211 | __FP_FRAC_SET_2(X, _FP_QNANNEGATEDP ? 0 : _FP_QNANBIT_D, 0x1); |

212 | #else |

213 | _FP_FRAC_SET_1(X, (_FP_QNANNEGATEDP ? 0 : _FP_QNANBIT_D) | 0x1); |

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 | } |

247 | |

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 |

267 | |

268 | return u.flt; |

269 | } |

270 | |

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); |

306 | #endif |

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 | } |

389 | |

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 | } |

789 |

Warning: That file was not part of the compilation database. It may have many parsing errors.