clang/lib/Headers/tgmath.h

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