nsz Git - libc-test/blob - src/math/fpclassify.c

   1 #include <stdio.h>
   2 #include <math.h>
   3
   4 #define T(a,b) {__LINE__, a, b},
   5 #define length(a) (sizeof(a)/sizeof*(a))
   6
   7 static struct {
   8         int line;
   9         float f;
  10         int class;
  11 } tf[] = {
  12         T(0.0/0.0, FP_NAN)
  13         T(-0.0/0.0, FP_NAN)
  14         T(1/0.0, FP_INFINITE)
  15         T(-1/0.0, FP_INFINITE)
  16         T(0x1.ffffp127, FP_NORMAL)
  17         T(-0x1.ffffp127, FP_NORMAL)
  18         T(0x1p-127, FP_SUBNORMAL)
  19         T(-0x1p-127, FP_SUBNORMAL)
  20         T(0.0, FP_ZERO)
  21         T(-0.0, FP_ZERO)
  22         T(3.14, FP_NORMAL)
  23         T(-42, FP_NORMAL)
  24 };
  25
  26 static struct {
  27         int line;
  28         double f;
  29         int class;
  30 } td[] = {
  31         T(0.0/0.0, FP_NAN)
  32         T(-0.0/0.0, FP_NAN)
  33         T(1/0.0, FP_INFINITE)
  34         T(-1/0.0, FP_INFINITE)
  35         T(0x1.ffffp1023, FP_NORMAL)
  36         T(-0x1.ffffp1023, FP_NORMAL)
  37         T(0x1p-1023, FP_SUBNORMAL)
  38         T(-0x1p-1023, FP_SUBNORMAL)
  39         T(0.0, FP_ZERO)
  40         T(-0.0, FP_ZERO)
  41         T(3.14, FP_NORMAL)
  42         T(-42, FP_NORMAL)
  43 };
  44
  45 static struct {
  46         int line;
  47         long double f;
  48         int class;
  49 } tl[] = {
  50         T(0.0/0.0, FP_NAN)
  51         T(-0.0/0.0, FP_NAN)
  52         T(1/0.0, FP_INFINITE)
  53         T(-1/0.0, FP_INFINITE)
  54         T(0x1.ffffp16383L, FP_NORMAL)
  55         T(-0x1.ffffp16383L, FP_NORMAL)
  56         T(0x1p-16383L, FP_SUBNORMAL)
  57         T(-0x1p-16383L, FP_SUBNORMAL)
  58         T(0.0, FP_ZERO)
  59         T(-0.0, FP_ZERO)
  60         T(3.14, FP_NORMAL)
  61         T(-42, FP_NORMAL)
  62 };
  63
  64 static char *strclass(int c)
  65 {
  66 #define C(n) case n: return #n;
  67         switch (c) {
  68         C(FP_NAN)
  69         C(FP_INFINITE)
  70         C(FP_ZERO)
  71         C(FP_SUBNORMAL)
  72         C(FP_NORMAL)
  73         }
  74         return "invalid";
  75 }
  76
  77 #define error(t,c) err++, printf("%s:%d: (at line %d) %La has class %d (%s), but %s returns %d\n", \
  78         __FILE__, __LINE__, t.line, (long double)t.f, t.class, strclass(t.class), #c, c(t.f))
  79
  80 int main()
  81 {
  82         int i;
  83         int err = 0;
  84
  85         for (i = 0; i < length(tf); i++) {
  86                 if (fpclassify(tf[i].f) != tf[i].class)
  87                         error(tf[i], fpclassify);
  88                 if (!!isinf(tf[i].f) != (tf[i].class == FP_INFINITE))
  89                         error(tf[i], isinf);
  90                 if (!!isnan(tf[i].f) != (tf[i].class == FP_NAN))
  91                         error(tf[i], isnan);
  92                 if (!!isnormal(tf[i].f) != (tf[i].class == FP_NORMAL))
  93                         error(tf[i], isnormal);
  94                 if (!!isfinite(tf[i].f) != (tf[i].class > FP_INFINITE))
  95                         error(tf[i], isfinite);
  96         }
  97
  98         for (i = 0; i < length(td); i++) {
  99                 if (fpclassify(td[i].f) != td[i].class)
 100                         error(td[i], fpclassify);
 101                 if (!!isinf(td[i].f) != (td[i].class == FP_INFINITE))
 102                         error(td[i], isinf);
 103                 if (!!isnan(td[i].f) != (td[i].class == FP_NAN))
 104                         error(td[i], isnan);
 105                 if (!!isnormal(td[i].f) != (td[i].class == FP_NORMAL))
 106                         error(td[i], isnormal);
 107                 if (!!isfinite(td[i].f) != (td[i].class > FP_INFINITE))
 108                         error(td[i], isfinite);
 109         }
 110
 111         for (i = 0; i < length(tl); i++) {
 112                 if (fpclassify(tl[i].f) != tl[i].class)
 113                         error(tl[i], fpclassify);
 114                 if (!!isinf(tl[i].f) != (tl[i].class == FP_INFINITE))
 115                         error(tl[i], isinf);
 116                 if (!!isnan(tl[i].f) != (tl[i].class == FP_NAN))
 117                         error(tl[i], isnan);
 118                 if (!!isnormal(tl[i].f) != (tl[i].class == FP_NORMAL))
 119                         error(tl[i], isnormal);
 120                 if (!!isfinite(tl[i].f) != (tl[i].class > FP_INFINITE))
 121                         error(tl[i], isfinite);
 122         }
 123
 124         return !!err;
 125 }