soft-fp/testit.c

   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_QNANBIT_D, 0x1234);
 204 #else
 205         _FP_FRAC_SET_1(X, _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_QNANBIT_D, 0x1);
 212 #else
 213         _FP_FRAC_SET_1(X, _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 }