sys/external/bsd/compiler_rt/dist/test/Unit/muldc3_test.c

   1 //===-- muldc3_test.c - Test __muldc3 -------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is dual licensed under the MIT and the University of Illinois Open
   6 // Source Licenses. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file tests __muldc3 for the compiler_rt library.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "int_lib.h"
  15 #include <math.h>
  16 #include <complex.h>
  17 #include <stdio.h>
  18
  19 // Returns: the product of a + ib and c + id
  20
  21 double _Complex __muldc3(double __a, double __b, double __c, double __d);
  22
  23 enum {zero, non_zero, inf, NaN, non_zero_nan};
  24
  25 int
  26 classify(double _Complex x)
  27 {
  28     if (x == 0)
  29         return zero;
  30     if (isinf(creal(x)) || isinf(cimag(x)))
  31         return inf;
  32     if (isnan(creal(x)) && isnan(cimag(x)))
  33         return NaN;
  34     if (isnan(creal(x)))
  35     {
  36         if (cimag(x) == 0)
  37             return NaN;
  38         return non_zero_nan;
  39     }
  40     if (isnan(cimag(x)))
  41     {
  42         if (creal(x) == 0)
  43             return NaN;
  44         return non_zero_nan;
  45     }
  46     return non_zero;
  47 }
  48
  49 int test__muldc3(double a, double b, double c, double d)
  50 {
  51     double _Complex r = __muldc3(a, b, c, d);
  52 //     printf("test__muldc3(%f, %f, %f, %f) = %f + I%f\n",
  53 //             a, b, c, d, creal(r), cimag(r));
  54         double _Complex dividend;
  55         double _Complex divisor;
  56
  57         __real__ dividend = a;
  58         __imag__ dividend = b;
  59         __real__ divisor = c;
  60         __imag__ divisor = d;
  61
  62     switch (classify(dividend))
  63     {
  64     case zero:
  65         switch (classify(divisor))
  66         {
  67         case zero:
  68             if (classify(r) != zero)
  69                 return 1;
  70             break;
  71         case non_zero:
  72             if (classify(r) != zero)
  73                 return 1;
  74             break;
  75         case inf:
  76             if (classify(r) != NaN)
  77                 return 1;
  78             break;
  79         case NaN:
  80             if (classify(r) != NaN)
  81                 return 1;
  82             break;
  83         case non_zero_nan:
  84             if (classify(r) != NaN)
  85                 return 1;
  86             break;
  87         }
  88         break;
  89     case non_zero:
  90         switch (classify(divisor))
  91         {
  92         case zero:
  93             if (classify(r) != zero)
  94                 return 1;
  95             break;
  96         case non_zero:
  97             if (classify(r) != non_zero)
  98                 return 1;
  99             if (r != a * c - b * d + _Complex_I*(a * d + b * c))
 100                 return 1;
 101             break;
 102         case inf:
 103             if (classify(r) != inf)
 104                 return 1;
 105             break;
 106         case NaN:
 107             if (classify(r) != NaN)
 108                 return 1;
 109             break;
 110         case non_zero_nan:
 111             if (classify(r) != NaN)
 112                 return 1;
 113             break;
 114         }
 115         break;
 116     case inf:
 117         switch (classify(divisor))
 118         {
 119         case zero:
 120             if (classify(r) != NaN)
 121                 return 1;
 122             break;
 123         case non_zero:
 124             if (classify(r) != inf)
 125                 return 1;
 126             break;
 127         case inf:
 128             if (classify(r) != inf)
 129                 return 1;
 130             break;
 131         case NaN:
 132             if (classify(r) != NaN)
 133                 return 1;
 134             break;
 135         case non_zero_nan:
 136             if (classify(r) != inf)
 137                 return 1;
 138             break;
 139         }
 140         break;
 141     case NaN:
 142         switch (classify(divisor))
 143         {
 144         case zero:
 145             if (classify(r) != NaN)
 146                 return 1;
 147             break;
 148         case non_zero:
 149             if (classify(r) != NaN)
 150                 return 1;
 151             break;
 152         case inf:
 153             if (classify(r) != NaN)
 154                 return 1;
 155             break;
 156         case NaN:
 157             if (classify(r) != NaN)
 158                 return 1;
 159             break;
 160         case non_zero_nan:
 161             if (classify(r) != NaN)
 162                 return 1;
 163             break;
 164         }
 165         break;
 166     case non_zero_nan:
 167         switch (classify(divisor))
 168         {
 169         case zero:
 170             if (classify(r) != NaN)
 171                 return 1;
 172             break;
 173         case non_zero:
 174             if (classify(r) != NaN)
 175                 return 1;
 176             break;
 177         case inf:
 178             if (classify(r) != inf)
 179                 return 1;
 180             break;
 181         case NaN:
 182             if (classify(r) != NaN)
 183                 return 1;
 184             break;
 185         case non_zero_nan:
 186             if (classify(r) != NaN)
 187                 return 1;
 188             break;
 189         }
 190         break;
 191     }
 192
 193     return 0;
 194 }
 195
 196 double x[][2] =
 197 {
 198     { 1.e-6,  1.e-6},
 199     {-1.e-6,  1.e-6},
 200     {-1.e-6, -1.e-6},
 201     { 1.e-6, -1.e-6},
 202
 203     { 1.e+6,  1.e-6},
 204     {-1.e+6,  1.e-6},
 205     {-1.e+6, -1.e-6},
 206     { 1.e+6, -1.e-6},
 207
 208     { 1.e-6,  1.e+6},
 209     {-1.e-6,  1.e+6},
 210     {-1.e-6, -1.e+6},
 211     { 1.e-6, -1.e+6},
 212
 213     { 1.e+6,  1.e+6},
 214     {-1.e+6,  1.e+6},
 215     {-1.e+6, -1.e+6},
 216     { 1.e+6, -1.e+6},
 217
 218     {NAN, NAN},
 219     {-INFINITY, NAN},
 220     {-2, NAN},
 221     {-1, NAN},
 222     {-0.5, NAN},
 223     {-0., NAN},
 224     {+0., NAN},
 225     {0.5, NAN},
 226     {1, NAN},
 227     {2, NAN},
 228     {INFINITY, NAN},
 229
 230     {NAN, -INFINITY},
 231     {-INFINITY, -INFINITY},
 232     {-2, -INFINITY},
 233     {-1, -INFINITY},
 234     {-0.5, -INFINITY},
 235     {-0., -INFINITY},
 236     {+0., -INFINITY},
 237     {0.5, -INFINITY},
 238     {1, -INFINITY},
 239     {2, -INFINITY},
 240     {INFINITY, -INFINITY},
 241
 242     {NAN, -2},
 243     {-INFINITY, -2},
 244     {-2, -2},
 245     {-1, -2},
 246     {-0.5, -2},
 247     {-0., -2},
 248     {+0., -2},
 249     {0.5, -2},
 250     {1, -2},
 251     {2, -2},
 252     {INFINITY, -2},
 253
 254     {NAN, -1},
 255     {-INFINITY, -1},
 256     {-2, -1},
 257     {-1, -1},
 258     {-0.5, -1},
 259     {-0., -1},
 260     {+0., -1},
 261     {0.5, -1},
 262     {1, -1},
 263     {2, -1},
 264     {INFINITY, -1},
 265
 266     {NAN, -0.5},
 267     {-INFINITY, -0.5},
 268     {-2, -0.5},
 269     {-1, -0.5},
 270     {-0.5, -0.5},
 271     {-0., -0.5},
 272     {+0., -0.5},
 273     {0.5, -0.5},
 274     {1, -0.5},
 275     {2, -0.5},
 276     {INFINITY, -0.5},
 277
 278     {NAN, -0.},
 279     {-INFINITY, -0.},
 280     {-2, -0.},
 281     {-1, -0.},
 282     {-0.5, -0.},
 283     {-0., -0.},
 284     {+0., -0.},
 285     {0.5, -0.},
 286     {1, -0.},
 287     {2, -0.},
 288     {INFINITY, -0.},
 289
 290     {NAN, 0.},
 291     {-INFINITY, 0.},
 292     {-2, 0.},
 293     {-1, 0.},
 294     {-0.5, 0.},
 295     {-0., 0.},
 296     {+0., 0.},
 297     {0.5, 0.},
 298     {1, 0.},
 299     {2, 0.},
 300     {INFINITY, 0.},
 301
 302     {NAN, 0.5},
 303     {-INFINITY, 0.5},
 304     {-2, 0.5},
 305     {-1, 0.5},
 306     {-0.5, 0.5},
 307     {-0., 0.5},
 308     {+0., 0.5},
 309     {0.5, 0.5},
 310     {1, 0.5},
 311     {2, 0.5},
 312     {INFINITY, 0.5},
 313
 314     {NAN, 1},
 315     {-INFINITY, 1},
 316     {-2, 1},
 317     {-1, 1},
 318     {-0.5, 1},
 319     {-0., 1},
 320     {+0., 1},
 321     {0.5, 1},
 322     {1, 1},
 323     {2, 1},
 324     {INFINITY, 1},
 325
 326     {NAN, 2},
 327     {-INFINITY, 2},
 328     {-2, 2},
 329     {-1, 2},
 330     {-0.5, 2},
 331     {-0., 2},
 332     {+0., 2},
 333     {0.5, 2},
 334     {1, 2},
 335     {2, 2},
 336     {INFINITY, 2},
 337
 338     {NAN, INFINITY},
 339     {-INFINITY, INFINITY},
 340     {-2, INFINITY},
 341     {-1, INFINITY},
 342     {-0.5, INFINITY},
 343     {-0., INFINITY},
 344     {+0., INFINITY},
 345     {0.5, INFINITY},
 346     {1, INFINITY},
 347     {2, INFINITY},
 348     {INFINITY, INFINITY}
 349
 350 };
 351
 352 int main()
 353 {
 354     const unsigned N = sizeof(x) / sizeof(x[0]);
 355     unsigned i, j;
 356     for (i = 0; i < N; ++i)
 357     {
 358         for (j = 0; j < N; ++j)
 359         {
 360             if (test__muldc3(x[i][0], x[i][1], x[j][0], x[j][1]))
 361                 return 1;
 362         }
 363     }
 364
 365     return 0;
 366 }