math/test-tgmath.c

   1 /* Test compilation of tgmath macros.
   2    Copyright (C) 2001 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Jakub Jelinek <jakub@redhat.com> and
   5    Ulrich Drepper <drepper@redhat.com>, 2001.
   6
   7    The GNU C Library is free software; you can redistribute it and/or
   8    modify it under the terms of the GNU Library General Public License as
   9    published by the Free Software Foundation; either version 2 of the
  10    License, or (at your option) any later version.
  11
  12    The GNU C Library is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15    Library General Public License for more details.
  16
  17    You should have received a copy of the GNU Library General Public
  18    License along with the GNU C Library; see the file COPYING.LIB.  If not,
  19    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #ifndef HAVE_MAIN
  23 #undef __NO_MATH_INLINES
  24 #define __NO_MATH_INLINES 1
  25 #include <math.h>
  26 #include <stdio.h>
  27 #include <tgmath.h>
  28
  29 //#define DEBUG
  30
  31 static void compile_test (void);
  32 static void compile_testf (void);
  33 static void compile_testl (void);
  34
  35 float fx;
  36 double dx;
  37 long double lx;
  38
  39 int count_double;
  40 int count_float;
  41 int count_ldouble;
  42
  43 #define NCALLS 115
  44
  45 int
  46 main (void)
  47 {
  48   int result = 0;
  49
  50   count_float = count_double = count_ldouble = 0;
  51   compile_test ();
  52   if (count_float != 0)
  53     {
  54       puts ("float function called for double test");
  55       result = 1;
  56     }
  57   if (count_ldouble != 0)
  58     {
  59       puts ("long double function called for double test");
  60       result = 1;
  61     }
  62   if (count_double < NCALLS)
  63     {
  64       printf ("double functions not called often enough (%d)\n",
  65               count_double);
  66       result = 1;
  67     }
  68   else if (count_double > NCALLS)
  69     {
  70       printf ("double functions called too often (%d)\n",
  71               count_double);
  72       result = 1;
  73     }
  74
  75   count_float = count_double = count_ldouble = 0;
  76   compile_testf ();
  77   if (count_double != 0)
  78     {
  79       puts ("double function called for float test");
  80       result = 1;
  81     }
  82   if (count_ldouble != 0)
  83     {
  84       puts ("long double function called for float test");
  85       result = 1;
  86     }
  87   if (count_float < NCALLS)
  88     {
  89       printf ("float functions not called often enough (%d)\n", count_float);
  90       result = 1;
  91     }
  92   else if (count_float > NCALLS)
  93     {
  94       printf ("float functions called too often (%d)\n",
  95               count_double);
  96       result = 1;
  97     }
  98
  99 #ifndef NO_LONG_DOUBLE
 100   count_float = count_double = count_ldouble = 0;
 101   compile_testl ();
 102   if (count_float != 0)
 103     {
 104       puts ("float function called for long double test");
 105       result = 1;
 106     }
 107   if (count_double != 0)
 108     {
 109       puts ("double function called for long double test");
 110       result = 1;
 111     }
 112   if (count_ldouble < NCALLS)
 113     {
 114       printf ("long double functions not called often enough (%d)\n",
 115               count_ldouble);
 116       result = 1;
 117     }
 118   else if (count_ldouble > NCALLS)
 119     {
 120       printf ("long double functions called too often (%d)\n",
 121               count_double);
 122       result = 1;
 123     }
 124 #endif
 125
 126   return result;
 127 }
 128
 129 /* Now generate the three functions.  */
 130 #define HAVE_MAIN
 131
 132 #define F(name) name
 133 #define TYPE double
 134 #define x dx
 135 #define count count_double
 136 #include "test-tgmath.c"
 137
 138 #define F(name) name##f
 139 #define TYPE float
 140 #define x fx
 141 #define count count_float
 142 #include "test-tgmath.c"
 143
 144 #ifndef NO_LONG_DOUBLE
 145 #define F(name) name##l
 146 #define TYPE long double
 147 #define x lx
 148 #define count count_ldouble
 149 #include "test-tgmath.c"
 150 #endif
 151
 152 #else
 153
 154 #ifdef DEBUG
 155 #define P() puts (__FUNCTION__)
 156 #else
 157 #define P()
 158 #endif
 159
 160 static void
 161 F(compile_test) (void)
 162 {
 163   TYPE a, b, c;
 164   int i;
 165   long int j;
 166   long long int k;
 167
 168   a = cos (cos (x));
 169   b = acos (acos (a));
 170   a = sin (sin (x));
 171   b = asin (asin (a));
 172   a = tan (tan (x));
 173   b = atan (atan (a));
 174   c = atan2 (atan2 (a, c), atan2 (b, x));
 175   a = cosh (cosh (x));
 176   b = acosh (acosh (a));
 177   a = sinh (sinh (x));
 178   b = asinh (asinh (a));
 179   a = tanh (tanh (x));
 180   b = atanh (atanh (a));
 181   a = exp (exp (x));
 182   b = log (log (a));
 183   a = log10 (log10 (x));
 184   b = ldexp (ldexp (a, 1), 5);
 185   a = frexp (frexp (x, &i), &i);
 186   b = expm1 (expm1 (a));
 187   a = log1p (log1p (x));
 188   b = logb (logb (a));
 189   a = exp2 (exp2 (x));
 190   b = log2 (log2 (a));
 191   a = pow (pow (x, a), pow (c, b));
 192   b = sqrt (sqrt (a));
 193   a = hypot (hypot (x, b), hypot (c, a));
 194   b = cbrt (cbrt (a));
 195   a = ceil (ceil (x));
 196   b = fabs (fabs (a));
 197   a = floor (floor (x));
 198   b = fmod (fmod (a, b), fmod (c, x));
 199   a = nearbyint (nearbyint (x));
 200   b = round (round (a));
 201   a = trunc (trunc (x));
 202   b = remquo (remquo (a, b, &i), remquo (c, x, &i), &i);
 203   j = lrint (x) + lround (a);
 204   k = llrint (b) + llround (c);
 205   a = erf (erf (x));
 206   b = erfc (erfc (a));
 207   a = tgamma (tgamma (x));
 208   b = lgamma (lgamma (a));
 209   a = rint (rint (x));
 210   b = nextafter (nextafter (a, b), nextafter (c, x));
 211   a = nexttoward (nexttoward (x, a), c);
 212   b = remainder (remainder (a, b), remainder (c, x));
 213   a = scalb (scalb (x, a), (TYPE) (6));
 214   k = scalbn (a, 7) + scalbln (c, 10l);
 215   i = ilogb (x);
 216   a = fdim (fdim (x, a), fdim (c, b));
 217   b = fmax (fmax (a, x), fmax (c, b));
 218   a = fmin (fmin (x, a), fmin (c, b));
 219   b = fma (sin (a), sin (x), sin (c));
 220 }
 221 #undef x
 222
 223
 224 TYPE
 225 (F(cos)) (TYPE x)
 226 {
 227   ++count;
 228   return x;
 229 }
 230
 231 TYPE
 232 (F(acos)) (TYPE x)
 233 {
 234   ++count;
 235   P();
 236   return x;
 237 }
 238
 239 TYPE
 240 (F(sin)) (TYPE x)
 241 {
 242   ++count;
 243   P();
 244   return x;
 245 }
 246
 247 TYPE
 248 (F(asin)) (TYPE x)
 249 {
 250   ++count;
 251   P();
 252   return x;
 253 }
 254
 255 TYPE
 256 (F(tan)) (TYPE x)
 257 {
 258   ++count;
 259   P();
 260   return x;
 261 }
 262
 263 TYPE
 264 (F(atan)) (TYPE x)
 265 {
 266   ++count;
 267   P();
 268   return x;
 269 }
 270
 271 TYPE
 272 (F(atan2)) (TYPE x, TYPE y)
 273 {
 274   ++count;
 275   P();
 276   return x + y;
 277 }
 278
 279 TYPE
 280 (F(cosh)) (TYPE x)
 281 {
 282   ++count;
 283   P();
 284   return x;
 285 }
 286
 287 TYPE
 288 (F(acosh)) (TYPE x)
 289 {
 290   ++count;
 291   P();
 292   return x;
 293 }
 294
 295 TYPE
 296 (F(sinh)) (TYPE x)
 297 {
 298   ++count;
 299   P();
 300   return x;
 301 }
 302
 303 TYPE
 304 (F(asinh)) (TYPE x)
 305 {
 306   ++count;
 307   P();
 308   return x;
 309 }
 310
 311 TYPE
 312 (F(tanh)) (TYPE x)
 313 {
 314   ++count;
 315   P();
 316   return x;
 317 }
 318
 319 TYPE
 320 (F(atanh)) (TYPE x)
 321 {
 322   ++count;
 323   P();
 324   return x;
 325 }
 326
 327 TYPE
 328 (F(exp)) (TYPE x)
 329 {
 330   ++count;
 331   P();
 332   return x;
 333 }
 334
 335 TYPE
 336 (F(log)) (TYPE x)
 337 {
 338   ++count;
 339   P();
 340   return x;
 341 }
 342
 343 TYPE
 344 (F(log10)) (TYPE x)
 345 {
 346   ++count;
 347   P();
 348   return x;
 349 }
 350
 351 TYPE
 352 (F(ldexp)) (TYPE x, int y)
 353 {
 354   ++count;
 355   P();
 356   return x;
 357 }
 358
 359 TYPE
 360 (F(frexp)) (TYPE x, int *y)
 361 {
 362   ++count;
 363   P();
 364   return x;
 365 }
 366
 367 TYPE
 368 (F(expm1)) (TYPE x)
 369 {
 370   ++count;
 371   P();
 372   return x;
 373 }
 374
 375 TYPE
 376 (F(log1p)) (TYPE x)
 377 {
 378   ++count;
 379   P();
 380   return x;
 381 }
 382
 383 TYPE
 384 (F(logb)) (TYPE x)
 385 {
 386   ++count;
 387   P();
 388   return x;
 389 }
 390
 391 TYPE
 392 (F(exp2)) (TYPE x)
 393 {
 394   ++count;
 395   P();
 396   return x;
 397 }
 398
 399 TYPE
 400 (F(log2)) (TYPE x)
 401 {
 402   ++count;
 403   P();
 404   return x;
 405 }
 406
 407 TYPE
 408 (F(pow)) (TYPE x, TYPE y)
 409 {
 410   ++count;
 411   P();
 412   return x + y;
 413 }
 414
 415 TYPE
 416 (F(sqrt)) (TYPE x)
 417 {
 418   ++count;
 419   P();
 420   return x;
 421 }
 422
 423 TYPE
 424 (F(hypot)) (TYPE x, TYPE y)
 425 {
 426   ++count;
 427   P();
 428   return x + y;
 429 }
 430
 431 TYPE
 432 (F(cbrt)) (TYPE x)
 433 {
 434   ++count;
 435   P();
 436   return x;
 437 }
 438
 439 TYPE
 440 (F(ceil)) (TYPE x)
 441 {
 442   ++count;
 443   P();
 444   return x;
 445 }
 446
 447 TYPE
 448 (F(fabs)) (TYPE x)
 449 {
 450   ++count;
 451   P();
 452   return x;
 453 }
 454
 455 TYPE
 456 (F(floor)) (TYPE x)
 457 {
 458   ++count;
 459   P();
 460   return x;
 461 }
 462
 463 TYPE
 464 (F(fmod)) (TYPE x, TYPE y)
 465 {
 466   ++count;
 467   P();
 468   return x + y;
 469 }
 470
 471 TYPE
 472 (F(nearbyint)) (TYPE x)
 473 {
 474   ++count;
 475   P();
 476   return x;
 477 }
 478
 479 TYPE
 480 (F(round)) (TYPE x)
 481 {
 482   ++count;
 483   P();
 484   return x;
 485 }
 486
 487 TYPE
 488 (F(trunc)) (TYPE x)
 489 {
 490   ++count;
 491   P();
 492   return x;
 493 }
 494
 495 TYPE
 496 (F(remquo)) (TYPE x, TYPE y, int *i)
 497 {
 498   ++count;
 499   P();
 500   return x + y;
 501 }
 502
 503 long int
 504 (F(lrint)) (TYPE x)
 505 {
 506   ++count;
 507   P();
 508   return x;
 509 }
 510
 511 long int
 512 (F(lround)) (TYPE x)
 513 {
 514   ++count;
 515   P();
 516   return x;
 517 }
 518
 519 long long int
 520 (F(llrint)) (TYPE x)
 521 {
 522   ++count;
 523   P();
 524   return x;
 525 }
 526
 527 long long int
 528 (F(llround)) (TYPE x)
 529 {
 530   ++count;
 531   P();
 532   return x;
 533 }
 534
 535 TYPE
 536 (F(erf)) (TYPE x)
 537 {
 538   ++count;
 539   P();
 540   return x;
 541 }
 542
 543 TYPE
 544 (F(erfc)) (TYPE x)
 545 {
 546   ++count;
 547   P();
 548   return x;
 549 }
 550
 551 TYPE
 552 (F(tgamma)) (TYPE x)
 553 {
 554   ++count;
 555   P();
 556   return x;
 557 }
 558
 559 TYPE
 560 (F(lgamma)) (TYPE x)
 561 {
 562   ++count;
 563   P();
 564   return x;
 565 }
 566
 567 TYPE
 568 (F(rint)) (TYPE x)
 569 {
 570   ++count;
 571   P();
 572   return x;
 573 }
 574
 575 TYPE
 576 (F(nextafter)) (TYPE x, TYPE y)
 577 {
 578   ++count;
 579   P();
 580   return x + y;
 581 }
 582
 583 TYPE
 584 (F(nexttoward)) (TYPE x, long double y)
 585 {
 586   ++count;
 587   P();
 588   return x;
 589 }
 590
 591 TYPE
 592 (F(remainder)) (TYPE x, TYPE y)
 593 {
 594   ++count;
 595   P();
 596   return x + y;
 597 }
 598
 599 TYPE
 600 (F(scalb)) (TYPE x, TYPE y)
 601 {
 602   ++count;
 603   P();
 604   return x + y;
 605 }
 606
 607 TYPE
 608 (F(scalbn)) (TYPE x, int y)
 609 {
 610   ++count;
 611   P();
 612   return x;
 613 }
 614
 615 TYPE
 616 (F(scalbln)) (TYPE x, long int y)
 617 {
 618   ++count;
 619   P();
 620   return x;
 621 }
 622
 623 int
 624 (F(ilogb)) (TYPE x)
 625 {
 626   ++count;
 627   P();
 628   return x;
 629 }
 630
 631 TYPE
 632 (F(fdim)) (TYPE x, TYPE y)
 633 {
 634   ++count;
 635   P();
 636   return x + y;
 637 }
 638
 639 TYPE
 640 (F(fmin)) (TYPE x, TYPE y)
 641 {
 642   ++count;
 643   P();
 644   return x + y;
 645 }
 646
 647 TYPE
 648 (F(fmax)) (TYPE x, TYPE y)
 649 {
 650   ++count;
 651   P();
 652   return x + y;
 653 }
 654
 655 TYPE
 656 (F(fma)) (TYPE x, TYPE y, TYPE z)
 657 {
 658   ++count;
 659   P();
 660   return x + y + z;
 661 }
 662
 663 #undef F
 664 #undef TYPE
 665 #undef count
 666 #endif