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