external/bsd/llvm/dist/clang/lib/Headers/tgmath.h

   1 /*===---- tgmath.h - Standard header for type generic math ----------------===*\
   2  *
   3  * Copyright (c) 2009 Howard Hinnant
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a copy
   6  * of this software and associated documentation files (the "Software"), to deal
   7  * in the Software without restriction, including without limitation the rights
   8  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   9  * copies of the Software, and to permit persons to whom the Software is
  10  * furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  21  * THE SOFTWARE.
  22  *
  23 \*===----------------------------------------------------------------------===*/
  24
  25 #ifndef __TGMATH_H
  26 #define __TGMATH_H
  27
  28 /* C99 7.22 Type-generic math <tgmath.h>. */
  29 #include <math.h>
  30
  31 /* C++ handles type genericity with overloading in math.h. */
  32 #ifndef __cplusplus
  33 #include <complex.h>
  34
  35 #define _TG_ATTRSp __attribute__((__overloadable__))
  36 #define _TG_ATTRS __attribute__((__overloadable__, __always_inline__))
  37
  38 // promotion
  39
  40 typedef void _Argument_type_is_not_arithmetic;
  41 static _Argument_type_is_not_arithmetic __tg_promote(...)
  42   __attribute__((__unavailable__,__overloadable__));
  43 static double               _TG_ATTRSp __tg_promote(int);
  44 static double               _TG_ATTRSp __tg_promote(unsigned int);
  45 static double               _TG_ATTRSp __tg_promote(long);
  46 static double               _TG_ATTRSp __tg_promote(unsigned long);
  47 static double               _TG_ATTRSp __tg_promote(long long);
  48 static double               _TG_ATTRSp __tg_promote(unsigned long long);
  49 static float                _TG_ATTRSp __tg_promote(float);
  50 static double               _TG_ATTRSp __tg_promote(double);
  51 static long double          _TG_ATTRSp __tg_promote(long double);
  52 static float _Complex       _TG_ATTRSp __tg_promote(float _Complex);
  53 static double _Complex      _TG_ATTRSp __tg_promote(double _Complex);
  54 static long double _Complex _TG_ATTRSp __tg_promote(long double _Complex);
  55
  56 #define __tg_promote1(__x)           (__typeof__(__tg_promote(__x)))
  57 #define __tg_promote2(__x, __y)      (__typeof__(__tg_promote(__x) + \
  58                                                  __tg_promote(__y)))
  59 #define __tg_promote3(__x, __y, __z) (__typeof__(__tg_promote(__x) + \
  60                                                  __tg_promote(__y) + \
  61                                                  __tg_promote(__z)))
  62
  63 // acos
  64
  65 static float
  66     _TG_ATTRS
  67     __tg_acos(float __x) {return acosf(__x);}
  68
  69 static double
  70     _TG_ATTRS
  71     __tg_acos(double __x) {return acos(__x);}
  72
  73 static long double
  74     _TG_ATTRS
  75     __tg_acos(long double __x) {return acosl(__x);}
  76
  77 static float _Complex
  78     _TG_ATTRS
  79     __tg_acos(float _Complex __x) {return cacosf(__x);}
  80
  81 static double _Complex
  82     _TG_ATTRS
  83     __tg_acos(double _Complex __x) {return cacos(__x);}
  84
  85 static long double _Complex
  86     _TG_ATTRS
  87     __tg_acos(long double _Complex __x) {return cacosl(__x);}
  88
  89 #undef acos
  90 #define acos(__x) __tg_acos(__tg_promote1((__x))(__x))
  91
  92 // asin
  93
  94 static float
  95     _TG_ATTRS
  96     __tg_asin(float __x) {return asinf(__x);}
  97
  98 static double
  99     _TG_ATTRS
 100     __tg_asin(double __x) {return asin(__x);}
 101
 102 static long double
 103     _TG_ATTRS
 104     __tg_asin(long double __x) {return asinl(__x);}
 105
 106 static float _Complex
 107     _TG_ATTRS
 108     __tg_asin(float _Complex __x) {return casinf(__x);}
 109
 110 static double _Complex
 111     _TG_ATTRS
 112     __tg_asin(double _Complex __x) {return casin(__x);}
 113
 114 static long double _Complex
 115     _TG_ATTRS
 116     __tg_asin(long double _Complex __x) {return casinl(__x);}
 117
 118 #undef asin
 119 #define asin(__x) __tg_asin(__tg_promote1((__x))(__x))
 120
 121 // atan
 122
 123 static float
 124     _TG_ATTRS
 125     __tg_atan(float __x) {return atanf(__x);}
 126
 127 static double
 128     _TG_ATTRS
 129     __tg_atan(double __x) {return atan(__x);}
 130
 131 static long double
 132     _TG_ATTRS
 133     __tg_atan(long double __x) {return atanl(__x);}
 134
 135 static float _Complex
 136     _TG_ATTRS
 137     __tg_atan(float _Complex __x) {return catanf(__x);}
 138
 139 static double _Complex
 140     _TG_ATTRS
 141     __tg_atan(double _Complex __x) {return catan(__x);}
 142
 143 static long double _Complex
 144     _TG_ATTRS
 145     __tg_atan(long double _Complex __x) {return catanl(__x);}
 146
 147 #undef atan
 148 #define atan(__x) __tg_atan(__tg_promote1((__x))(__x))
 149
 150 // acosh
 151
 152 static float
 153     _TG_ATTRS
 154     __tg_acosh(float __x) {return acoshf(__x);}
 155
 156 static double
 157     _TG_ATTRS
 158     __tg_acosh(double __x) {return acosh(__x);}
 159
 160 static long double
 161     _TG_ATTRS
 162     __tg_acosh(long double __x) {return acoshl(__x);}
 163
 164 static float _Complex
 165     _TG_ATTRS
 166     __tg_acosh(float _Complex __x) {return cacoshf(__x);}
 167
 168 static double _Complex
 169     _TG_ATTRS
 170     __tg_acosh(double _Complex __x) {return cacosh(__x);}
 171
 172 static long double _Complex
 173     _TG_ATTRS
 174     __tg_acosh(long double _Complex __x) {return cacoshl(__x);}
 175
 176 #undef acosh
 177 #define acosh(__x) __tg_acosh(__tg_promote1((__x))(__x))
 178
 179 // asinh
 180
 181 static float
 182     _TG_ATTRS
 183     __tg_asinh(float __x) {return asinhf(__x);}
 184
 185 static double
 186     _TG_ATTRS
 187     __tg_asinh(double __x) {return asinh(__x);}
 188
 189 static long double
 190     _TG_ATTRS
 191     __tg_asinh(long double __x) {return asinhl(__x);}
 192
 193 static float _Complex
 194     _TG_ATTRS
 195     __tg_asinh(float _Complex __x) {return casinhf(__x);}
 196
 197 static double _Complex
 198     _TG_ATTRS
 199     __tg_asinh(double _Complex __x) {return casinh(__x);}
 200
 201 static long double _Complex
 202     _TG_ATTRS
 203     __tg_asinh(long double _Complex __x) {return casinhl(__x);}
 204
 205 #undef asinh
 206 #define asinh(__x) __tg_asinh(__tg_promote1((__x))(__x))
 207
 208 // atanh
 209
 210 static float
 211     _TG_ATTRS
 212     __tg_atanh(float __x) {return atanhf(__x);}
 213
 214 static double
 215     _TG_ATTRS
 216     __tg_atanh(double __x) {return atanh(__x);}
 217
 218 static long double
 219     _TG_ATTRS
 220     __tg_atanh(long double __x) {return atanhl(__x);}
 221
 222 static float _Complex
 223     _TG_ATTRS
 224     __tg_atanh(float _Complex __x) {return catanhf(__x);}
 225
 226 static double _Complex
 227     _TG_ATTRS
 228     __tg_atanh(double _Complex __x) {return catanh(__x);}
 229
 230 static long double _Complex
 231     _TG_ATTRS
 232     __tg_atanh(long double _Complex __x) {return catanhl(__x);}
 233
 234 #undef atanh
 235 #define atanh(__x) __tg_atanh(__tg_promote1((__x))(__x))
 236
 237 // cos
 238
 239 static float
 240     _TG_ATTRS
 241     __tg_cos(float __x) {return cosf(__x);}
 242
 243 static double
 244     _TG_ATTRS
 245     __tg_cos(double __x) {return cos(__x);}
 246
 247 static long double
 248     _TG_ATTRS
 249     __tg_cos(long double __x) {return cosl(__x);}
 250
 251 static float _Complex
 252     _TG_ATTRS
 253     __tg_cos(float _Complex __x) {return ccosf(__x);}
 254
 255 static double _Complex
 256     _TG_ATTRS
 257     __tg_cos(double _Complex __x) {return ccos(__x);}
 258
 259 static long double _Complex
 260     _TG_ATTRS
 261     __tg_cos(long double _Complex __x) {return ccosl(__x);}
 262
 263 #undef cos
 264 #define cos(__x) __tg_cos(__tg_promote1((__x))(__x))
 265
 266 // sin
 267
 268 static float
 269     _TG_ATTRS
 270     __tg_sin(float __x) {return sinf(__x);}
 271
 272 static double
 273     _TG_ATTRS
 274     __tg_sin(double __x) {return sin(__x);}
 275
 276 static long double
 277     _TG_ATTRS
 278     __tg_sin(long double __x) {return sinl(__x);}
 279
 280 static float _Complex
 281     _TG_ATTRS
 282     __tg_sin(float _Complex __x) {return csinf(__x);}
 283
 284 static double _Complex
 285     _TG_ATTRS
 286     __tg_sin(double _Complex __x) {return csin(__x);}
 287
 288 static long double _Complex
 289     _TG_ATTRS
 290     __tg_sin(long double _Complex __x) {return csinl(__x);}
 291
 292 #undef sin
 293 #define sin(__x) __tg_sin(__tg_promote1((__x))(__x))
 294
 295 // tan
 296
 297 static float
 298     _TG_ATTRS
 299     __tg_tan(float __x) {return tanf(__x);}
 300
 301 static double
 302     _TG_ATTRS
 303     __tg_tan(double __x) {return tan(__x);}
 304
 305 static long double
 306     _TG_ATTRS
 307     __tg_tan(long double __x) {return tanl(__x);}
 308
 309 static float _Complex
 310     _TG_ATTRS
 311     __tg_tan(float _Complex __x) {return ctanf(__x);}
 312
 313 static double _Complex
 314     _TG_ATTRS
 315     __tg_tan(double _Complex __x) {return ctan(__x);}
 316
 317 static long double _Complex
 318     _TG_ATTRS
 319     __tg_tan(long double _Complex __x) {return ctanl(__x);}
 320
 321 #undef tan
 322 #define tan(__x) __tg_tan(__tg_promote1((__x))(__x))
 323
 324 // cosh
 325
 326 static float
 327     _TG_ATTRS
 328     __tg_cosh(float __x) {return coshf(__x);}
 329
 330 static double
 331     _TG_ATTRS
 332     __tg_cosh(double __x) {return cosh(__x);}
 333
 334 static long double
 335     _TG_ATTRS
 336     __tg_cosh(long double __x) {return coshl(__x);}
 337
 338 static float _Complex
 339     _TG_ATTRS
 340     __tg_cosh(float _Complex __x) {return ccoshf(__x);}
 341
 342 static double _Complex
 343     _TG_ATTRS
 344     __tg_cosh(double _Complex __x) {return ccosh(__x);}
 345
 346 static long double _Complex
 347     _TG_ATTRS
 348     __tg_cosh(long double _Complex __x) {return ccoshl(__x);}
 349
 350 #undef cosh
 351 #define cosh(__x) __tg_cosh(__tg_promote1((__x))(__x))
 352
 353 // sinh
 354
 355 static float
 356     _TG_ATTRS
 357     __tg_sinh(float __x) {return sinhf(__x);}
 358
 359 static double
 360     _TG_ATTRS
 361     __tg_sinh(double __x) {return sinh(__x);}
 362
 363 static long double
 364     _TG_ATTRS
 365     __tg_sinh(long double __x) {return sinhl(__x);}
 366
 367 static float _Complex
 368     _TG_ATTRS
 369     __tg_sinh(float _Complex __x) {return csinhf(__x);}
 370
 371 static double _Complex
 372     _TG_ATTRS
 373     __tg_sinh(double _Complex __x) {return csinh(__x);}
 374
 375 static long double _Complex
 376     _TG_ATTRS
 377     __tg_sinh(long double _Complex __x) {return csinhl(__x);}
 378
 379 #undef sinh
 380 #define sinh(__x) __tg_sinh(__tg_promote1((__x))(__x))
 381
 382 // tanh
 383
 384 static float
 385     _TG_ATTRS
 386     __tg_tanh(float __x) {return tanhf(__x);}
 387
 388 static double
 389     _TG_ATTRS
 390     __tg_tanh(double __x) {return tanh(__x);}
 391
 392 static long double
 393     _TG_ATTRS
 394     __tg_tanh(long double __x) {return tanhl(__x);}
 395
 396 static float _Complex
 397     _TG_ATTRS
 398     __tg_tanh(float _Complex __x) {return ctanhf(__x);}
 399
 400 static double _Complex
 401     _TG_ATTRS
 402     __tg_tanh(double _Complex __x) {return ctanh(__x);}
 403
 404 static long double _Complex
 405     _TG_ATTRS
 406     __tg_tanh(long double _Complex __x) {return ctanhl(__x);}
 407
 408 #undef tanh
 409 #define tanh(__x) __tg_tanh(__tg_promote1((__x))(__x))
 410
 411 // exp
 412
 413 static float
 414     _TG_ATTRS
 415     __tg_exp(float __x) {return expf(__x);}
 416
 417 static double
 418     _TG_ATTRS
 419     __tg_exp(double __x) {return exp(__x);}
 420
 421 static long double
 422     _TG_ATTRS
 423     __tg_exp(long double __x) {return expl(__x);}
 424
 425 static float _Complex
 426     _TG_ATTRS
 427     __tg_exp(float _Complex __x) {return cexpf(__x);}
 428
 429 static double _Complex
 430     _TG_ATTRS
 431     __tg_exp(double _Complex __x) {return cexp(__x);}
 432
 433 static long double _Complex
 434     _TG_ATTRS
 435     __tg_exp(long double _Complex __x) {return cexpl(__x);}
 436
 437 #undef exp
 438 #define exp(__x) __tg_exp(__tg_promote1((__x))(__x))
 439
 440 // log
 441
 442 static float
 443     _TG_ATTRS
 444     __tg_log(float __x) {return logf(__x);}
 445
 446 static double
 447     _TG_ATTRS
 448     __tg_log(double __x) {return log(__x);}
 449
 450 static long double
 451     _TG_ATTRS
 452     __tg_log(long double __x) {return logl(__x);}
 453
 454 static float _Complex
 455     _TG_ATTRS
 456     __tg_log(float _Complex __x) {return clogf(__x);}
 457
 458 static double _Complex
 459     _TG_ATTRS
 460     __tg_log(double _Complex __x) {return clog(__x);}
 461
 462 static long double _Complex
 463     _TG_ATTRS
 464     __tg_log(long double _Complex __x) {return clogl(__x);}
 465
 466 #undef log
 467 #define log(__x) __tg_log(__tg_promote1((__x))(__x))
 468
 469 // pow
 470
 471 static float
 472     _TG_ATTRS
 473     __tg_pow(float __x, float __y) {return powf(__x, __y);}
 474
 475 static double
 476     _TG_ATTRS
 477     __tg_pow(double __x, double __y) {return pow(__x, __y);}
 478
 479 static long double
 480     _TG_ATTRS
 481     __tg_pow(long double __x, long double __y) {return powl(__x, __y);}
 482
 483 static float _Complex
 484     _TG_ATTRS
 485     __tg_pow(float _Complex __x, float _Complex __y) {return cpowf(__x, __y);}
 486
 487 static double _Complex
 488     _TG_ATTRS
 489     __tg_pow(double _Complex __x, double _Complex __y) {return cpow(__x, __y);}
 490
 491 static long double _Complex
 492     _TG_ATTRS
 493     __tg_pow(long double _Complex __x, long double _Complex __y)
 494     {return cpowl(__x, __y);}
 495
 496 #undef pow
 497 #define pow(__x, __y) __tg_pow(__tg_promote2((__x), (__y))(__x), \
 498                                __tg_promote2((__x), (__y))(__y))
 499
 500 // sqrt
 501
 502 static float
 503     _TG_ATTRS
 504     __tg_sqrt(float __x) {return sqrtf(__x);}
 505
 506 static double
 507     _TG_ATTRS
 508     __tg_sqrt(double __x) {return sqrt(__x);}
 509
 510 static long double
 511     _TG_ATTRS
 512     __tg_sqrt(long double __x) {return sqrtl(__x);}
 513
 514 static float _Complex
 515     _TG_ATTRS
 516     __tg_sqrt(float _Complex __x) {return csqrtf(__x);}
 517
 518 static double _Complex
 519     _TG_ATTRS
 520     __tg_sqrt(double _Complex __x) {return csqrt(__x);}
 521
 522 static long double _Complex
 523     _TG_ATTRS
 524     __tg_sqrt(long double _Complex __x) {return csqrtl(__x);}
 525
 526 #undef sqrt
 527 #define sqrt(__x) __tg_sqrt(__tg_promote1((__x))(__x))
 528
 529 // fabs
 530
 531 static float
 532     _TG_ATTRS
 533     __tg_fabs(float __x) {return fabsf(__x);}
 534
 535 static double
 536     _TG_ATTRS
 537     __tg_fabs(double __x) {return fabs(__x);}
 538
 539 static long double
 540     _TG_ATTRS
 541     __tg_fabs(long double __x) {return fabsl(__x);}
 542
 543 static float
 544     _TG_ATTRS
 545     __tg_fabs(float _Complex __x) {return cabsf(__x);}
 546
 547 static double
 548     _TG_ATTRS
 549     __tg_fabs(double _Complex __x) {return cabs(__x);}
 550
 551 static long double
 552     _TG_ATTRS
 553     __tg_fabs(long double _Complex __x) {return cabsl(__x);}
 554
 555 #undef fabs
 556 #define fabs(__x) __tg_fabs(__tg_promote1((__x))(__x))
 557
 558 // atan2
 559
 560 static float
 561     _TG_ATTRS
 562     __tg_atan2(float __x, float __y) {return atan2f(__x, __y);}
 563
 564 static double
 565     _TG_ATTRS
 566     __tg_atan2(double __x, double __y) {return atan2(__x, __y);}
 567
 568 static long double
 569     _TG_ATTRS
 570     __tg_atan2(long double __x, long double __y) {return atan2l(__x, __y);}
 571
 572 #undef atan2
 573 #define atan2(__x, __y) __tg_atan2(__tg_promote2((__x), (__y))(__x), \
 574                                    __tg_promote2((__x), (__y))(__y))
 575
 576 // cbrt
 577
 578 static float
 579     _TG_ATTRS
 580     __tg_cbrt(float __x) {return cbrtf(__x);}
 581
 582 static double
 583     _TG_ATTRS
 584     __tg_cbrt(double __x) {return cbrt(__x);}
 585
 586 static long double
 587     _TG_ATTRS
 588     __tg_cbrt(long double __x) {return cbrtl(__x);}
 589
 590 #undef cbrt
 591 #define cbrt(__x) __tg_cbrt(__tg_promote1((__x))(__x))
 592
 593 // ceil
 594
 595 static float
 596     _TG_ATTRS
 597     __tg_ceil(float __x) {return ceilf(__x);}
 598
 599 static double
 600     _TG_ATTRS
 601     __tg_ceil(double __x) {return ceil(__x);}
 602
 603 static long double
 604     _TG_ATTRS
 605     __tg_ceil(long double __x) {return ceill(__x);}
 606
 607 #undef ceil
 608 #define ceil(__x) __tg_ceil(__tg_promote1((__x))(__x))
 609
 610 // copysign
 611
 612 static float
 613     _TG_ATTRS
 614     __tg_copysign(float __x, float __y) {return copysignf(__x, __y);}
 615
 616 static double
 617     _TG_ATTRS
 618     __tg_copysign(double __x, double __y) {return copysign(__x, __y);}
 619
 620 static long double
 621     _TG_ATTRS
 622     __tg_copysign(long double __x, long double __y) {return copysignl(__x, __y);}
 623
 624 #undef copysign
 625 #define copysign(__x, __y) __tg_copysign(__tg_promote2((__x), (__y))(__x), \
 626                                          __tg_promote2((__x), (__y))(__y))
 627
 628 // erf
 629
 630 static float
 631     _TG_ATTRS
 632     __tg_erf(float __x) {return erff(__x);}
 633
 634 static double
 635     _TG_ATTRS
 636     __tg_erf(double __x) {return erf(__x);}
 637
 638 static long double
 639     _TG_ATTRS
 640     __tg_erf(long double __x) {return erfl(__x);}
 641
 642 #undef erf
 643 #define erf(__x) __tg_erf(__tg_promote1((__x))(__x))
 644
 645 // erfc
 646
 647 static float
 648     _TG_ATTRS
 649     __tg_erfc(float __x) {return erfcf(__x);}
 650
 651 static double
 652     _TG_ATTRS
 653     __tg_erfc(double __x) {return erfc(__x);}
 654
 655 static long double
 656     _TG_ATTRS
 657     __tg_erfc(long double __x) {return erfcl(__x);}
 658
 659 #undef erfc
 660 #define erfc(__x) __tg_erfc(__tg_promote1((__x))(__x))
 661
 662 // exp2
 663
 664 static float
 665     _TG_ATTRS
 666     __tg_exp2(float __x) {return exp2f(__x);}
 667
 668 static double
 669     _TG_ATTRS
 670     __tg_exp2(double __x) {return exp2(__x);}
 671
 672 static long double
 673     _TG_ATTRS
 674     __tg_exp2(long double __x) {return exp2l(__x);}
 675
 676 #undef exp2
 677 #define exp2(__x) __tg_exp2(__tg_promote1((__x))(__x))
 678
 679 // expm1
 680
 681 static float
 682     _TG_ATTRS
 683     __tg_expm1(float __x) {return expm1f(__x);}
 684
 685 static double
 686     _TG_ATTRS
 687     __tg_expm1(double __x) {return expm1(__x);}
 688
 689 static long double
 690     _TG_ATTRS
 691     __tg_expm1(long double __x) {return expm1l(__x);}
 692
 693 #undef expm1
 694 #define expm1(__x) __tg_expm1(__tg_promote1((__x))(__x))
 695
 696 // fdim
 697
 698 static float
 699     _TG_ATTRS
 700     __tg_fdim(float __x, float __y) {return fdimf(__x, __y);}
 701
 702 static double
 703     _TG_ATTRS
 704     __tg_fdim(double __x, double __y) {return fdim(__x, __y);}
 705
 706 static long double
 707     _TG_ATTRS
 708     __tg_fdim(long double __x, long double __y) {return fdiml(__x, __y);}
 709
 710 #undef fdim
 711 #define fdim(__x, __y) __tg_fdim(__tg_promote2((__x), (__y))(__x), \
 712                                  __tg_promote2((__x), (__y))(__y))
 713
 714 // floor
 715
 716 static float
 717     _TG_ATTRS
 718     __tg_floor(float __x) {return floorf(__x);}
 719
 720 static double
 721     _TG_ATTRS
 722     __tg_floor(double __x) {return floor(__x);}
 723
 724 static long double
 725     _TG_ATTRS
 726     __tg_floor(long double __x) {return floorl(__x);}
 727
 728 #undef floor
 729 #define floor(__x) __tg_floor(__tg_promote1((__x))(__x))
 730
 731 // fma
 732
 733 static float
 734     _TG_ATTRS
 735     __tg_fma(float __x, float __y, float __z)
 736     {return fmaf(__x, __y, __z);}
 737
 738 static double
 739     _TG_ATTRS
 740     __tg_fma(double __x, double __y, double __z)
 741     {return fma(__x, __y, __z);}
 742
 743 static long double
 744     _TG_ATTRS
 745     __tg_fma(long double __x,long double __y, long double __z)
 746     {return fmal(__x, __y, __z);}
 747
 748 #undef fma
 749 #define fma(__x, __y, __z)                                \
 750         __tg_fma(__tg_promote3((__x), (__y), (__z))(__x), \
 751                  __tg_promote3((__x), (__y), (__z))(__y), \
 752                  __tg_promote3((__x), (__y), (__z))(__z))
 753
 754 // fmax
 755
 756 static float
 757     _TG_ATTRS
 758     __tg_fmax(float __x, float __y) {return fmaxf(__x, __y);}
 759
 760 static double
 761     _TG_ATTRS
 762     __tg_fmax(double __x, double __y) {return fmax(__x, __y);}
 763
 764 static long double
 765     _TG_ATTRS
 766     __tg_fmax(long double __x, long double __y) {return fmaxl(__x, __y);}
 767
 768 #undef fmax
 769 #define fmax(__x, __y) __tg_fmax(__tg_promote2((__x), (__y))(__x), \
 770                                  __tg_promote2((__x), (__y))(__y))
 771
 772 // fmin
 773
 774 static float
 775     _TG_ATTRS
 776     __tg_fmin(float __x, float __y) {return fminf(__x, __y);}
 777
 778 static double
 779     _TG_ATTRS
 780     __tg_fmin(double __x, double __y) {return fmin(__x, __y);}
 781
 782 static long double
 783     _TG_ATTRS
 784     __tg_fmin(long double __x, long double __y) {return fminl(__x, __y);}
 785
 786 #undef fmin
 787 #define fmin(__x, __y) __tg_fmin(__tg_promote2((__x), (__y))(__x), \
 788                                  __tg_promote2((__x), (__y))(__y))
 789
 790 // fmod
 791
 792 static float
 793     _TG_ATTRS
 794     __tg_fmod(float __x, float __y) {return fmodf(__x, __y);}
 795
 796 static double
 797     _TG_ATTRS
 798     __tg_fmod(double __x, double __y) {return fmod(__x, __y);}
 799
 800 static long double
 801     _TG_ATTRS
 802     __tg_fmod(long double __x, long double __y) {return fmodl(__x, __y);}
 803
 804 #undef fmod
 805 #define fmod(__x, __y) __tg_fmod(__tg_promote2((__x), (__y))(__x), \
 806                                  __tg_promote2((__x), (__y))(__y))
 807
 808 // frexp
 809
 810 static float
 811     _TG_ATTRS
 812     __tg_frexp(float __x, int* __y) {return frexpf(__x, __y);}
 813
 814 static double
 815     _TG_ATTRS
 816     __tg_frexp(double __x, int* __y) {return frexp(__x, __y);}
 817
 818 static long double
 819     _TG_ATTRS
 820     __tg_frexp(long double __x, int* __y) {return frexpl(__x, __y);}
 821
 822 #undef frexp
 823 #define frexp(__x, __y) __tg_frexp(__tg_promote1((__x))(__x), __y)
 824
 825 // hypot
 826
 827 static float
 828     _TG_ATTRS
 829     __tg_hypot(float __x, float __y) {return hypotf(__x, __y);}
 830
 831 static double
 832     _TG_ATTRS
 833     __tg_hypot(double __x, double __y) {return hypot(__x, __y);}
 834
 835 static long double
 836     _TG_ATTRS
 837     __tg_hypot(long double __x, long double __y) {return hypotl(__x, __y);}
 838
 839 #undef hypot
 840 #define hypot(__x, __y) __tg_hypot(__tg_promote2((__x), (__y))(__x), \
 841                                    __tg_promote2((__x), (__y))(__y))
 842
 843 // ilogb
 844
 845 static int
 846     _TG_ATTRS
 847     __tg_ilogb(float __x) {return ilogbf(__x);}
 848
 849 static int
 850     _TG_ATTRS
 851     __tg_ilogb(double __x) {return ilogb(__x);}
 852
 853 static int
 854     _TG_ATTRS
 855     __tg_ilogb(long double __x) {return ilogbl(__x);}
 856
 857 #undef ilogb
 858 #define ilogb(__x) __tg_ilogb(__tg_promote1((__x))(__x))
 859
 860 // ldexp
 861
 862 static float
 863     _TG_ATTRS
 864     __tg_ldexp(float __x, int __y) {return ldexpf(__x, __y);}
 865
 866 static double
 867     _TG_ATTRS
 868     __tg_ldexp(double __x, int __y) {return ldexp(__x, __y);}
 869
 870 static long double
 871     _TG_ATTRS
 872     __tg_ldexp(long double __x, int __y) {return ldexpl(__x, __y);}
 873
 874 #undef ldexp
 875 #define ldexp(__x, __y) __tg_ldexp(__tg_promote1((__x))(__x), __y)
 876
 877 // lgamma
 878
 879 static float
 880     _TG_ATTRS
 881     __tg_lgamma(float __x) {return lgammaf(__x);}
 882
 883 static double
 884     _TG_ATTRS
 885     __tg_lgamma(double __x) {return lgamma(__x);}
 886
 887 static long double
 888     _TG_ATTRS
 889     __tg_lgamma(long double __x) {return lgammal(__x);}
 890
 891 #undef lgamma
 892 #define lgamma(__x) __tg_lgamma(__tg_promote1((__x))(__x))
 893
 894 // llrint
 895
 896 static long long
 897     _TG_ATTRS
 898     __tg_llrint(float __x) {return llrintf(__x);}
 899
 900 static long long
 901     _TG_ATTRS
 902     __tg_llrint(double __x) {return llrint(__x);}
 903
 904 static long long
 905     _TG_ATTRS
 906     __tg_llrint(long double __x) {return llrintl(__x);}
 907
 908 #undef llrint
 909 #define llrint(__x) __tg_llrint(__tg_promote1((__x))(__x))
 910
 911 // llround
 912
 913 static long long
 914     _TG_ATTRS
 915     __tg_llround(float __x) {return llroundf(__x);}
 916
 917 static long long
 918     _TG_ATTRS
 919     __tg_llround(double __x) {return llround(__x);}
 920
 921 static long long
 922     _TG_ATTRS
 923     __tg_llround(long double __x) {return llroundl(__x);}
 924
 925 #undef llround
 926 #define llround(__x) __tg_llround(__tg_promote1((__x))(__x))
 927
 928 // log10
 929
 930 static float
 931     _TG_ATTRS
 932     __tg_log10(float __x) {return log10f(__x);}
 933
 934 static double
 935     _TG_ATTRS
 936     __tg_log10(double __x) {return log10(__x);}
 937
 938 static long double
 939     _TG_ATTRS
 940     __tg_log10(long double __x) {return log10l(__x);}
 941
 942 #undef log10
 943 #define log10(__x) __tg_log10(__tg_promote1((__x))(__x))
 944
 945 // log1p
 946
 947 static float
 948     _TG_ATTRS
 949     __tg_log1p(float __x) {return log1pf(__x);}
 950
 951 static double
 952     _TG_ATTRS
 953     __tg_log1p(double __x) {return log1p(__x);}
 954
 955 static long double
 956     _TG_ATTRS
 957     __tg_log1p(long double __x) {return log1pl(__x);}
 958
 959 #undef log1p
 960 #define log1p(__x) __tg_log1p(__tg_promote1((__x))(__x))
 961
 962 // log2
 963
 964 static float
 965     _TG_ATTRS
 966     __tg_log2(float __x) {return log2f(__x);}
 967
 968 static double
 969     _TG_ATTRS
 970     __tg_log2(double __x) {return log2(__x);}
 971
 972 static long double
 973     _TG_ATTRS
 974     __tg_log2(long double __x) {return log2l(__x);}
 975
 976 #undef log2
 977 #define log2(__x) __tg_log2(__tg_promote1((__x))(__x))
 978
 979 // logb
 980
 981 static float
 982     _TG_ATTRS
 983     __tg_logb(float __x) {return logbf(__x);}
 984
 985 static double
 986     _TG_ATTRS
 987     __tg_logb(double __x) {return logb(__x);}
 988
 989 static long double
 990     _TG_ATTRS
 991     __tg_logb(long double __x) {return logbl(__x);}
 992
 993 #undef logb
 994 #define logb(__x) __tg_logb(__tg_promote1((__x))(__x))
 995
 996 // lrint
 997
 998 static long
 999     _TG_ATTRS
1000     __tg_lrint(float __x) {return lrintf(__x);}
1001
1002 static long
1003     _TG_ATTRS
1004     __tg_lrint(double __x) {return lrint(__x);}
1005
1006 static long
1007     _TG_ATTRS
1008     __tg_lrint(long double __x) {return lrintl(__x);}
1009
1010 #undef lrint
1011 #define lrint(__x) __tg_lrint(__tg_promote1((__x))(__x))
1012
1013 // lround
1014
1015 static long
1016     _TG_ATTRS
1017     __tg_lround(float __x) {return lroundf(__x);}
1018
1019 static long
1020     _TG_ATTRS
1021     __tg_lround(double __x) {return lround(__x);}
1022
1023 static long
1024     _TG_ATTRS
1025     __tg_lround(long double __x) {return lroundl(__x);}
1026
1027 #undef lround
1028 #define lround(__x) __tg_lround(__tg_promote1((__x))(__x))
1029
1030 // nearbyint
1031
1032 static float
1033     _TG_ATTRS
1034     __tg_nearbyint(float __x) {return nearbyintf(__x);}
1035
1036 static double
1037     _TG_ATTRS
1038     __tg_nearbyint(double __x) {return nearbyint(__x);}
1039
1040 static long double
1041     _TG_ATTRS
1042     __tg_nearbyint(long double __x) {return nearbyintl(__x);}
1043
1044 #undef nearbyint
1045 #define nearbyint(__x) __tg_nearbyint(__tg_promote1((__x))(__x))
1046
1047 // nextafter
1048
1049 static float
1050     _TG_ATTRS
1051     __tg_nextafter(float __x, float __y) {return nextafterf(__x, __y);}
1052
1053 static double
1054     _TG_ATTRS
1055     __tg_nextafter(double __x, double __y) {return nextafter(__x, __y);}
1056
1057 static long double
1058     _TG_ATTRS
1059     __tg_nextafter(long double __x, long double __y) {return nextafterl(__x, __y);}
1060
1061 #undef nextafter
1062 #define nextafter(__x, __y) __tg_nextafter(__tg_promote2((__x), (__y))(__x), \
1063                                            __tg_promote2((__x), (__y))(__y))
1064
1065 // nexttoward
1066
1067 static float
1068     _TG_ATTRS
1069     __tg_nexttoward(float __x, long double __y) {return nexttowardf(__x, __y);}
1070
1071 static double
1072     _TG_ATTRS
1073     __tg_nexttoward(double __x, long double __y) {return nexttoward(__x, __y);}
1074
1075 static long double
1076     _TG_ATTRS
1077     __tg_nexttoward(long double __x, long double __y) {return nexttowardl(__x, __y);}
1078
1079 #undef nexttoward
1080 #define nexttoward(__x, __y) __tg_nexttoward(__tg_promote1((__x))(__x), (__y))
1081
1082 // remainder
1083
1084 static float
1085     _TG_ATTRS
1086     __tg_remainder(float __x, float __y) {return remainderf(__x, __y);}
1087
1088 static double
1089     _TG_ATTRS
1090     __tg_remainder(double __x, double __y) {return remainder(__x, __y);}
1091
1092 static long double
1093     _TG_ATTRS
1094     __tg_remainder(long double __x, long double __y) {return remainderl(__x, __y);}
1095
1096 #undef remainder
1097 #define remainder(__x, __y) __tg_remainder(__tg_promote2((__x), (__y))(__x), \
1098                                            __tg_promote2((__x), (__y))(__y))
1099
1100 // remquo
1101
1102 static float
1103     _TG_ATTRS
1104     __tg_remquo(float __x, float __y, int* __z)
1105     {return remquof(__x, __y, __z);}
1106
1107 static double
1108     _TG_ATTRS
1109     __tg_remquo(double __x, double __y, int* __z)
1110     {return remquo(__x, __y, __z);}
1111
1112 static long double
1113     _TG_ATTRS
1114     __tg_remquo(long double __x,long double __y, int* __z)
1115     {return remquol(__x, __y, __z);}
1116
1117 #undef remquo
1118 #define remquo(__x, __y, __z)                         \
1119         __tg_remquo(__tg_promote2((__x), (__y))(__x), \
1120                     __tg_promote2((__x), (__y))(__y), \
1121                     (__z))
1122
1123 // rint
1124
1125 static float
1126     _TG_ATTRS
1127     __tg_rint(float __x) {return rintf(__x);}
1128
1129 static double
1130     _TG_ATTRS
1131     __tg_rint(double __x) {return rint(__x);}
1132
1133 static long double
1134     _TG_ATTRS
1135     __tg_rint(long double __x) {return rintl(__x);}
1136
1137 #undef rint
1138 #define rint(__x) __tg_rint(__tg_promote1((__x))(__x))
1139
1140 // round
1141
1142 static float
1143     _TG_ATTRS
1144     __tg_round(float __x) {return roundf(__x);}
1145
1146 static double
1147     _TG_ATTRS
1148     __tg_round(double __x) {return round(__x);}
1149
1150 static long double
1151     _TG_ATTRS
1152     __tg_round(long double __x) {return roundl(__x);}
1153
1154 #undef round
1155 #define round(__x) __tg_round(__tg_promote1((__x))(__x))
1156
1157 // scalbn
1158
1159 static float
1160     _TG_ATTRS
1161     __tg_scalbn(float __x, int __y) {return scalbnf(__x, __y);}
1162
1163 static double
1164     _TG_ATTRS
1165     __tg_scalbn(double __x, int __y) {return scalbn(__x, __y);}
1166
1167 static long double
1168     _TG_ATTRS
1169     __tg_scalbn(long double __x, int __y) {return scalbnl(__x, __y);}
1170
1171 #undef scalbn
1172 #define scalbn(__x, __y) __tg_scalbn(__tg_promote1((__x))(__x), __y)
1173
1174 // scalbln
1175
1176 static float
1177     _TG_ATTRS
1178     __tg_scalbln(float __x, long __y) {return scalblnf(__x, __y);}
1179
1180 static double
1181     _TG_ATTRS
1182     __tg_scalbln(double __x, long __y) {return scalbln(__x, __y);}
1183
1184 static long double
1185     _TG_ATTRS
1186     __tg_scalbln(long double __x, long __y) {return scalblnl(__x, __y);}
1187
1188 #undef scalbln
1189 #define scalbln(__x, __y) __tg_scalbln(__tg_promote1((__x))(__x), __y)
1190
1191 // tgamma
1192
1193 static float
1194     _TG_ATTRS
1195     __tg_tgamma(float __x) {return tgammaf(__x);}
1196
1197 static double
1198     _TG_ATTRS
1199     __tg_tgamma(double __x) {return tgamma(__x);}
1200
1201 static long double
1202     _TG_ATTRS
1203     __tg_tgamma(long double __x) {return tgammal(__x);}
1204
1205 #undef tgamma
1206 #define tgamma(__x) __tg_tgamma(__tg_promote1((__x))(__x))
1207
1208 // trunc
1209
1210 static float
1211     _TG_ATTRS
1212     __tg_trunc(float __x) {return truncf(__x);}
1213
1214 static double
1215     _TG_ATTRS
1216     __tg_trunc(double __x) {return trunc(__x);}
1217
1218 static long double
1219     _TG_ATTRS
1220     __tg_trunc(long double __x) {return truncl(__x);}
1221
1222 #undef trunc
1223 #define trunc(__x) __tg_trunc(__tg_promote1((__x))(__x))
1224
1225 // carg
1226
1227 static float
1228     _TG_ATTRS
1229     __tg_carg(float __x) {return atan2f(0.F, __x);}
1230
1231 static double
1232     _TG_ATTRS
1233     __tg_carg(double __x) {return atan2(0., __x);}
1234
1235 static long double
1236     _TG_ATTRS
1237     __tg_carg(long double __x) {return atan2l(0.L, __x);}
1238
1239 static float
1240     _TG_ATTRS
1241     __tg_carg(float _Complex __x) {return cargf(__x);}
1242
1243 static double
1244     _TG_ATTRS
1245     __tg_carg(double _Complex __x) {return carg(__x);}
1246
1247 static long double
1248     _TG_ATTRS
1249     __tg_carg(long double _Complex __x) {return cargl(__x);}
1250
1251 #undef carg
1252 #define carg(__x) __tg_carg(__tg_promote1((__x))(__x))
1253
1254 // cimag
1255
1256 static float
1257     _TG_ATTRS
1258     __tg_cimag(float __x) {return 0;}
1259
1260 static double
1261     _TG_ATTRS
1262     __tg_cimag(double __x) {return 0;}
1263
1264 static long double
1265     _TG_ATTRS
1266     __tg_cimag(long double __x) {return 0;}
1267
1268 static float
1269     _TG_ATTRS
1270     __tg_cimag(float _Complex __x) {return cimagf(__x);}
1271
1272 static double
1273     _TG_ATTRS
1274     __tg_cimag(double _Complex __x) {return cimag(__x);}
1275
1276 static long double
1277     _TG_ATTRS
1278     __tg_cimag(long double _Complex __x) {return cimagl(__x);}
1279
1280 #undef cimag
1281 #define cimag(__x) __tg_cimag(__tg_promote1((__x))(__x))
1282
1283 // conj
1284
1285 static float _Complex
1286     _TG_ATTRS
1287     __tg_conj(float __x) {return __x;}
1288
1289 static double _Complex
1290     _TG_ATTRS
1291     __tg_conj(double __x) {return __x;}
1292
1293 static long double _Complex
1294     _TG_ATTRS
1295     __tg_conj(long double __x) {return __x;}
1296
1297 static float _Complex
1298     _TG_ATTRS
1299     __tg_conj(float _Complex __x) {return conjf(__x);}
1300
1301 static double _Complex
1302     _TG_ATTRS
1303     __tg_conj(double _Complex __x) {return conj(__x);}
1304
1305 static long double _Complex
1306     _TG_ATTRS
1307     __tg_conj(long double _Complex __x) {return conjl(__x);}
1308
1309 #undef conj
1310 #define conj(__x) __tg_conj(__tg_promote1((__x))(__x))
1311
1312 // cproj
1313
1314 static float _Complex
1315     _TG_ATTRS
1316     __tg_cproj(float __x) {return cprojf(__x);}
1317
1318 static double _Complex
1319     _TG_ATTRS
1320     __tg_cproj(double __x) {return cproj(__x);}
1321
1322 static long double _Complex
1323     _TG_ATTRS
1324     __tg_cproj(long double __x) {return cprojl(__x);}
1325
1326 static float _Complex
1327     _TG_ATTRS
1328     __tg_cproj(float _Complex __x) {return cprojf(__x);}
1329
1330 static double _Complex
1331     _TG_ATTRS
1332     __tg_cproj(double _Complex __x) {return cproj(__x);}
1333
1334 static long double _Complex
1335     _TG_ATTRS
1336     __tg_cproj(long double _Complex __x) {return cprojl(__x);}
1337
1338 #undef cproj
1339 #define cproj(__x) __tg_cproj(__tg_promote1((__x))(__x))
1340
1341 // creal
1342
1343 static float
1344     _TG_ATTRS
1345     __tg_creal(float __x) {return __x;}
1346
1347 static double
1348     _TG_ATTRS
1349     __tg_creal(double __x) {return __x;}
1350
1351 static long double
1352     _TG_ATTRS
1353     __tg_creal(long double __x) {return __x;}
1354
1355 static float
1356     _TG_ATTRS
1357     __tg_creal(float _Complex __x) {return crealf(__x);}
1358
1359 static double
1360     _TG_ATTRS
1361     __tg_creal(double _Complex __x) {return creal(__x);}
1362
1363 static long double
1364     _TG_ATTRS
1365     __tg_creal(long double _Complex __x) {return creall(__x);}
1366
1367 #undef creal
1368 #define creal(__x) __tg_creal(__tg_promote1((__x))(__x))
1369
1370 #undef _TG_ATTRSp
1371 #undef _TG_ATTRS
1372
1373 #endif /* __cplusplus */
1374 #endif /* __TGMATH_H */