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 33typedef void _Argument_type_is_not_arithmetic; 34static _Argument_type_is_not_arithmetic __tg_promote(...) 35 __attribute__((__unavailable__,__overloadable__)); 36static double _TG_ATTRSp __tg_promote(int); 37static double _TG_ATTRSp __tg_promote(unsigned int); 38static double _TG_ATTRSp __tg_promote(long); 39static double _TG_ATTRSp __tg_promote(unsigned long); 40static double _TG_ATTRSp __tg_promote(long long); 41static double _TG_ATTRSp __tg_promote(unsigned long long); 42static float _TG_ATTRSp __tg_promote(float); 43static double _TG_ATTRSp __tg_promote(double); 44static long double _TG_ATTRSp __tg_promote(long double); 45static float _Complex _TG_ATTRSp __tg_promote(float _Complex); 46static double _Complex _TG_ATTRSp __tg_promote(double _Complex); 47static 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 58static float 59 _TG_ATTRS 60 __tg_acos(float __x) {return acosf(__x);} 61 62static double 63 _TG_ATTRS 64 __tg_acos(double __x) {return acos(__x);} 65 66static long double 67 _TG_ATTRS 68 __tg_acos(long double __x) {return acosl(__x);} 69 70static float _Complex 71 _TG_ATTRS 72 __tg_acos(float _Complex __x) {return cacosf(__x);} 73 74static double _Complex 75 _TG_ATTRS 76 __tg_acos(double _Complex __x) {return cacos(__x);} 77 78static 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 87static float 88 _TG_ATTRS 89 __tg_asin(float __x) {return asinf(__x);} 90 91static double 92 _TG_ATTRS 93 __tg_asin(double __x) {return asin(__x);} 94 95static long double 96 _TG_ATTRS 97 __tg_asin(long double __x) {return asinl(__x);} 98 99static float _Complex 100 _TG_ATTRS 101 __tg_asin(float _Complex __x) {return casinf(__x);} 102 103static double _Complex 104 _TG_ATTRS 105 __tg_asin(double _Complex __x) {return casin(__x);} 106 107static 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 116static float 117 _TG_ATTRS 118 __tg_atan(float __x) {return atanf(__x);} 119 120static double 121 _TG_ATTRS 122 __tg_atan(double __x) {return atan(__x);} 123 124static long double 125 _TG_ATTRS 126 __tg_atan(long double __x) {return atanl(__x);} 127 128static float _Complex 129 _TG_ATTRS 130 __tg_atan(float _Complex __x) {return catanf(__x);} 131 132static double _Complex 133 _TG_ATTRS 134 __tg_atan(double _Complex __x) {return catan(__x);} 135 136static 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 145static float 146 _TG_ATTRS 147 __tg_acosh(float __x) {return acoshf(__x);} 148 149static double 150 _TG_ATTRS 151 __tg_acosh(double __x) {return acosh(__x);} 152 153static long double 154 _TG_ATTRS 155 __tg_acosh(long double __x) {return acoshl(__x);} 156 157static float _Complex 158 _TG_ATTRS 159 __tg_acosh(float _Complex __x) {return cacoshf(__x);} 160 161static double _Complex 162 _TG_ATTRS 163 __tg_acosh(double _Complex __x) {return cacosh(__x);} 164 165static 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 174static float 175 _TG_ATTRS 176 __tg_asinh(float __x) {return asinhf(__x);} 177 178static double 179 _TG_ATTRS 180 __tg_asinh(double __x) {return asinh(__x);} 181 182static long double 183 _TG_ATTRS 184 __tg_asinh(long double __x) {return asinhl(__x);} 185 186static float _Complex 187 _TG_ATTRS 188 __tg_asinh(float _Complex __x) {return casinhf(__x);} 189 190static double _Complex 191 _TG_ATTRS 192 __tg_asinh(double _Complex __x) {return casinh(__x);} 193 194static 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 203static float 204 _TG_ATTRS 205 __tg_atanh(float __x) {return atanhf(__x);} 206 207static double 208 _TG_ATTRS 209 __tg_atanh(double __x) {return atanh(__x);} 210 211static long double 212 _TG_ATTRS 213 __tg_atanh(long double __x) {return atanhl(__x);} 214 215static float _Complex 216 _TG_ATTRS 217 __tg_atanh(float _Complex __x) {return catanhf(__x);} 218 219static double _Complex 220 _TG_ATTRS 221 __tg_atanh(double _Complex __x) {return catanh(__x);} 222 223static 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 232static float 233 _TG_ATTRS 234 __tg_cos(float __x) {return cosf(__x);} 235 236static double 237 _TG_ATTRS 238 __tg_cos(double __x) {return cos(__x);} 239 240static long double 241 _TG_ATTRS 242 __tg_cos(long double __x) {return cosl(__x);} 243 244static float _Complex 245 _TG_ATTRS 246 __tg_cos(float _Complex __x) {return ccosf(__x);} 247 248static double _Complex 249 _TG_ATTRS 250 __tg_cos(double _Complex __x) {return ccos(__x);} 251 252static 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 261static float 262 _TG_ATTRS 263 __tg_sin(float __x) {return sinf(__x);} 264 265static double 266 _TG_ATTRS 267 __tg_sin(double __x) {return sin(__x);} 268 269static long double 270 _TG_ATTRS 271 __tg_sin(long double __x) {return sinl(__x);} 272 273static float _Complex 274 _TG_ATTRS 275 __tg_sin(float _Complex __x) {return csinf(__x);} 276 277static double _Complex 278 _TG_ATTRS 279 __tg_sin(double _Complex __x) {return csin(__x);} 280 281static 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 290static float 291 _TG_ATTRS 292 __tg_tan(float __x) {return tanf(__x);} 293 294static double 295 _TG_ATTRS 296 __tg_tan(double __x) {return tan(__x);} 297 298static long double 299 _TG_ATTRS 300 __tg_tan(long double __x) {return tanl(__x);} 301 302static float _Complex 303 _TG_ATTRS 304 __tg_tan(float _Complex __x) {return ctanf(__x);} 305 306static double _Complex 307 _TG_ATTRS 308 __tg_tan(double _Complex __x) {return ctan(__x);} 309 310static 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 319static float 320 _TG_ATTRS 321 __tg_cosh(float __x) {return coshf(__x);} 322 323static double 324 _TG_ATTRS 325 __tg_cosh(double __x) {return cosh(__x);} 326 327static long double 328 _TG_ATTRS 329 __tg_cosh(long double __x) {return coshl(__x);} 330 331static float _Complex 332 _TG_ATTRS 333 __tg_cosh(float _Complex __x) {return ccoshf(__x);} 334 335static double _Complex 336 _TG_ATTRS 337 __tg_cosh(double _Complex __x) {return ccosh(__x);} 338 339static 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 348static float 349 _TG_ATTRS 350 __tg_sinh(float __x) {return sinhf(__x);} 351 352static double 353 _TG_ATTRS 354 __tg_sinh(double __x) {return sinh(__x);} 355 356static long double 357 _TG_ATTRS 358 __tg_sinh(long double __x) {return sinhl(__x);} 359 360static float _Complex 361 _TG_ATTRS 362 __tg_sinh(float _Complex __x) {return csinhf(__x);} 363 364static double _Complex 365 _TG_ATTRS 366 __tg_sinh(double _Complex __x) {return csinh(__x);} 367 368static 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 377static float 378 _TG_ATTRS 379 __tg_tanh(float __x) {return tanhf(__x);} 380 381static double 382 _TG_ATTRS 383 __tg_tanh(double __x) {return tanh(__x);} 384 385static long double 386 _TG_ATTRS 387 __tg_tanh(long double __x) {return tanhl(__x);} 388 389static float _Complex 390 _TG_ATTRS 391 __tg_tanh(float _Complex __x) {return ctanhf(__x);} 392 393static double _Complex 394 _TG_ATTRS 395 __tg_tanh(double _Complex __x) {return ctanh(__x);} 396 397static 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 406static float 407 _TG_ATTRS 408 __tg_exp(float __x) {return expf(__x);} 409 410static double 411 _TG_ATTRS 412 __tg_exp(double __x) {return exp(__x);} 413 414static long double 415 _TG_ATTRS 416 __tg_exp(long double __x) {return expl(__x);} 417 418static float _Complex 419 _TG_ATTRS 420 __tg_exp(float _Complex __x) {return cexpf(__x);} 421 422static double _Complex 423 _TG_ATTRS 424 __tg_exp(double _Complex __x) {return cexp(__x);} 425 426static 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 435static float 436 _TG_ATTRS 437 __tg_log(float __x) {return logf(__x);} 438 439static double 440 _TG_ATTRS 441 __tg_log(double __x) {return log(__x);} 442 443static long double 444 _TG_ATTRS 445 __tg_log(long double __x) {return logl(__x);} 446 447static float _Complex 448 _TG_ATTRS 449 __tg_log(float _Complex __x) {return clogf(__x);} 450 451static double _Complex 452 _TG_ATTRS 453 __tg_log(double _Complex __x) {return clog(__x);} 454 455static 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 464static float 465 _TG_ATTRS 466 __tg_pow(float __x, float __y) {return powf(__x, __y);} 467 468static double 469 _TG_ATTRS 470 __tg_pow(double __x, double __y) {return pow(__x, __y);} 471 472static long double 473 _TG_ATTRS 474 __tg_pow(long double __x, long double __y) {return powl(__x, __y);} 475 476static float _Complex 477 _TG_ATTRS 478 __tg_pow(float _Complex __x, float _Complex __y) {return cpowf(__x, __y);} 479 480static double _Complex 481 _TG_ATTRS 482 __tg_pow(double _Complex __x, double _Complex __y) {return cpow(__x, __y);} 483 484static 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 495static float 496 _TG_ATTRS 497 __tg_sqrt(float __x) {return sqrtf(__x);} 498 499static double 500 _TG_ATTRS 501 __tg_sqrt(double __x) {return sqrt(__x);} 502 503static long double 504 _TG_ATTRS 505 __tg_sqrt(long double __x) {return sqrtl(__x);} 506 507static float _Complex 508 _TG_ATTRS 509 __tg_sqrt(float _Complex __x) {return csqrtf(__x);} 510 511static double _Complex 512 _TG_ATTRS 513 __tg_sqrt(double _Complex __x) {return csqrt(__x);} 514 515static 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 524static float 525 _TG_ATTRS 526 __tg_fabs(float __x) {return fabsf(__x);} 527 528static double 529 _TG_ATTRS 530 __tg_fabs(double __x) {return fabs(__x);} 531 532static long double 533 _TG_ATTRS 534 __tg_fabs(long double __x) {return fabsl(__x);} 535 536static float 537 _TG_ATTRS 538 __tg_fabs(float _Complex __x) {return cabsf(__x);} 539 540static double 541 _TG_ATTRS 542 __tg_fabs(double _Complex __x) {return cabs(__x);} 543 544static 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 553static float 554 _TG_ATTRS 555 __tg_atan2(float __x, float __y) {return atan2f(__x, __y);} 556 557static double 558 _TG_ATTRS 559 __tg_atan2(double __x, double __y) {return atan2(__x, __y);} 560 561static 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 571static float 572 _TG_ATTRS 573 __tg_cbrt(float __x) {return cbrtf(__x);} 574 575static double 576 _TG_ATTRS 577 __tg_cbrt(double __x) {return cbrt(__x);} 578 579static 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 588static float 589 _TG_ATTRS 590 __tg_ceil(float __x) {return ceilf(__x);} 591 592static double 593 _TG_ATTRS 594 __tg_ceil(double __x) {return ceil(__x);} 595 596static 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 605static float 606 _TG_ATTRS 607 __tg_copysign(float __x, float __y) {return copysignf(__x, __y);} 608 609static double 610 _TG_ATTRS 611 __tg_copysign(double __x, double __y) {return copysign(__x, __y);} 612 613static 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 623static float 624 _TG_ATTRS 625 __tg_erf(float __x) {return erff(__x);} 626 627static double 628 _TG_ATTRS 629 __tg_erf(double __x) {return erf(__x);} 630 631static 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 640static float 641 _TG_ATTRS 642 __tg_erfc(float __x) {return erfcf(__x);} 643 644static double 645 _TG_ATTRS 646 __tg_erfc(double __x) {return erfc(__x);} 647 648static 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 657static float 658 _TG_ATTRS 659 __tg_exp2(float __x) {return exp2f(__x);} 660 661static double 662 _TG_ATTRS 663 __tg_exp2(double __x) {return exp2(__x);} 664 665static 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 674static float 675 _TG_ATTRS 676 __tg_expm1(float __x) {return expm1f(__x);} 677 678static double 679 _TG_ATTRS 680 __tg_expm1(double __x) {return expm1(__x);} 681 682static 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 691static float 692 _TG_ATTRS 693 __tg_fdim(float __x, float __y) {return fdimf(__x, __y);} 694 695static double 696 _TG_ATTRS 697 __tg_fdim(double __x, double __y) {return fdim(__x, __y);} 698 699static 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 709static float 710 _TG_ATTRS 711 __tg_floor(float __x) {return floorf(__x);} 712 713static double 714 _TG_ATTRS 715 __tg_floor(double __x) {return floor(__x);} 716 717static 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 726static float 727 _TG_ATTRS 728 __tg_fma(float __x, float __y, float __z) 729 {return fmaf(__x, __y, __z);} 730 731static double 732 _TG_ATTRS 733 __tg_fma(double __x, double __y, double __z) 734 {return fma(__x, __y, __z);} 735 736static 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 749static float 750 _TG_ATTRS 751 __tg_fmax(float __x, float __y) {return fmaxf(__x, __y);} 752 753static double 754 _TG_ATTRS 755 __tg_fmax(double __x, double __y) {return fmax(__x, __y);} 756 757static 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 767static float 768 _TG_ATTRS 769 __tg_fmin(float __x, float __y) {return fminf(__x, __y);} 770 771static double 772 _TG_ATTRS 773 __tg_fmin(double __x, double __y) {return fmin(__x, __y);} 774 775static 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 785static float 786 _TG_ATTRS 787 __tg_fmod(float __x, float __y) {return fmodf(__x, __y);} 788 789static double 790 _TG_ATTRS 791 __tg_fmod(double __x, double __y) {return fmod(__x, __y);} 792 793static 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 803static float 804 _TG_ATTRS 805 __tg_frexp(float __x, int* __y) {return frexpf(__x, __y);} 806 807static double 808 _TG_ATTRS 809 __tg_frexp(double __x, int* __y) {return frexp(__x, __y);} 810 811static 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 820static float 821 _TG_ATTRS 822 __tg_hypot(float __x, float __y) {return hypotf(__x, __y);} 823 824static double 825 _TG_ATTRS 826 __tg_hypot(double __x, double __y) {return hypot(__x, __y);} 827 828static 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 838static int 839 _TG_ATTRS 840 __tg_ilogb(float __x) {return ilogbf(__x);} 841 842static int 843 _TG_ATTRS 844 __tg_ilogb(double __x) {return ilogb(__x);} 845 846static 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 855static float 856 _TG_ATTRS 857 __tg_ldexp(float __x, int __y) {return ldexpf(__x, __y);} 858 859static double 860 _TG_ATTRS 861 __tg_ldexp(double __x, int __y) {return ldexp(__x, __y);} 862 863static 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 872static float 873 _TG_ATTRS 874 __tg_lgamma(float __x) {return lgammaf(__x);} 875 876static double 877 _TG_ATTRS 878 __tg_lgamma(double __x) {return lgamma(__x);} 879 880static 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 889static long long 890 _TG_ATTRS 891 __tg_llrint(float __x) {return llrintf(__x);} 892 893static long long 894 _TG_ATTRS 895 __tg_llrint(double __x) {return llrint(__x);} 896 897static 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 906static long long 907 _TG_ATTRS 908 __tg_llround(float __x) {return llroundf(__x);} 909 910static long long 911 _TG_ATTRS 912 __tg_llround(double __x) {return llround(__x);} 913 914static 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 923static float 924 _TG_ATTRS 925 __tg_log10(float __x) {return log10f(__x);} 926 927static double 928 _TG_ATTRS 929 __tg_log10(double __x) {return log10(__x);} 930 931static 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 940static float 941 _TG_ATTRS 942 __tg_log1p(float __x) {return log1pf(__x);} 943 944static double 945 _TG_ATTRS 946 __tg_log1p(double __x) {return log1p(__x);} 947 948static 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 957static float 958 _TG_ATTRS 959 __tg_log2(float __x) {return log2f(__x);} 960 961static double 962 _TG_ATTRS 963 __tg_log2(double __x) {return log2(__x);} 964 965static 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 974static float 975 _TG_ATTRS 976 __tg_logb(float __x) {return logbf(__x);} 977 978static double 979 _TG_ATTRS 980 __tg_logb(double __x) {return logb(__x);} 981 982static 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 991static long 992 _TG_ATTRS 993 __tg_lrint(float __x) {return lrintf(__x);} 994 995static long 996 _TG_ATTRS 997 __tg_lrint(double __x) {return lrint(__x);} 998 999static 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 1008static long 1009 _TG_ATTRS 1010 __tg_lround(float __x) {return lroundf(__x);} 1011 1012static long 1013 _TG_ATTRS 1014 __tg_lround(double __x) {return lround(__x);} 1015 1016static 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 1025static float 1026 _TG_ATTRS 1027 __tg_nearbyint(float __x) {return nearbyintf(__x);} 1028 1029static double 1030 _TG_ATTRS 1031 __tg_nearbyint(double __x) {return nearbyint(__x);} 1032 1033static 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 1042static float 1043 _TG_ATTRS 1044 __tg_nextafter(float __x, float __y) {return nextafterf(__x, __y);} 1045 1046static double 1047 _TG_ATTRS 1048 __tg_nextafter(double __x, double __y) {return nextafter(__x, __y);} 1049 1050static 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 1060static float 1061 _TG_ATTRS 1062 __tg_nexttoward(float __x, long double __y) {return nexttowardf(__x, __y);} 1063 1064static double 1065 _TG_ATTRS 1066 __tg_nexttoward(double __x, long double __y) {return nexttoward(__x, __y);} 1067 1068static 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 1077static float 1078 _TG_ATTRS 1079 __tg_remainder(float __x, float __y) {return remainderf(__x, __y);} 1080 1081static double 1082 _TG_ATTRS 1083 __tg_remainder(double __x, double __y) {return remainder(__x, __y);} 1084 1085static 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 1095static float 1096 _TG_ATTRS 1097 __tg_remquo(float __x, float __y, int* __z) 1098 {return remquof(__x, __y, __z);} 1099 1100static double 1101 _TG_ATTRS 1102 __tg_remquo(double __x, double __y, int* __z) 1103 {return remquo(__x, __y, __z);} 1104 1105static 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 1118static float 1119 _TG_ATTRS 1120 __tg_rint(float __x) {return rintf(__x);} 1121 1122static double 1123 _TG_ATTRS 1124 __tg_rint(double __x) {return rint(__x);} 1125 1126static 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 1135static float 1136 _TG_ATTRS 1137 __tg_round(float __x) {return roundf(__x);} 1138 1139static double 1140 _TG_ATTRS 1141 __tg_round(double __x) {return round(__x);} 1142 1143static 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 1152static float 1153 _TG_ATTRS 1154 __tg_scalbn(float __x, int __y) {return scalbnf(__x, __y);} 1155 1156static double 1157 _TG_ATTRS 1158 __tg_scalbn(double __x, int __y) {return scalbn(__x, __y);} 1159 1160static 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 1169static float 1170 _TG_ATTRS 1171 __tg_scalbln(float __x, long __y) {return scalblnf(__x, __y);} 1172 1173static double 1174 _TG_ATTRS 1175 __tg_scalbln(double __x, long __y) {return scalbln(__x, __y);} 1176 1177static 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 1186static float 1187 _TG_ATTRS 1188 __tg_tgamma(float __x) {return tgammaf(__x);} 1189 1190static double 1191 _TG_ATTRS 1192 __tg_tgamma(double __x) {return tgamma(__x);} 1193 1194static 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 1203static float 1204 _TG_ATTRS 1205 __tg_trunc(float __x) {return truncf(__x);} 1206 1207static double 1208 _TG_ATTRS 1209 __tg_trunc(double __x) {return trunc(__x);} 1210 1211static 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 1220static float 1221 _TG_ATTRS 1222 __tg_carg(float __x) {return atan2f(0.F, __x);} 1223 1224static double 1225 _TG_ATTRS 1226 __tg_carg(double __x) {return atan2(0., __x);} 1227 1228static long double 1229 _TG_ATTRS 1230 __tg_carg(long double __x) {return atan2l(0.L, __x);} 1231 1232static float 1233 _TG_ATTRS 1234 __tg_carg(float _Complex __x) {return cargf(__x);} 1235 1236static double 1237 _TG_ATTRS 1238 __tg_carg(double _Complex __x) {return carg(__x);} 1239 1240static 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 1249static float 1250 _TG_ATTRS 1251 __tg_cimag(float __x) {return 0;} 1252 1253static double 1254 _TG_ATTRS 1255 __tg_cimag(double __x) {return 0;} 1256 1257static long double 1258 _TG_ATTRS 1259 __tg_cimag(long double __x) {return 0;} 1260 1261static float 1262 _TG_ATTRS 1263 __tg_cimag(float _Complex __x) {return cimagf(__x);} 1264 1265static double 1266 _TG_ATTRS 1267 __tg_cimag(double _Complex __x) {return cimag(__x);} 1268 1269static 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 1278static float _Complex 1279 _TG_ATTRS 1280 __tg_conj(float __x) {return __x;} 1281 1282static double _Complex 1283 _TG_ATTRS 1284 __tg_conj(double __x) {return __x;} 1285 1286static long double _Complex 1287 _TG_ATTRS 1288 __tg_conj(long double __x) {return __x;} 1289 1290static float _Complex 1291 _TG_ATTRS 1292 __tg_conj(float _Complex __x) {return conjf(__x);} 1293 1294static double _Complex 1295 _TG_ATTRS 1296 __tg_conj(double _Complex __x) {return conj(__x);} 1297 1298static 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 1307static float _Complex 1308 _TG_ATTRS 1309 __tg_cproj(float __x) {return cprojf(__x);} 1310 1311static double _Complex 1312 _TG_ATTRS 1313 __tg_cproj(double __x) {return cproj(__x);} 1314 1315static long double _Complex 1316 _TG_ATTRS 1317 __tg_cproj(long double __x) {return cprojl(__x);} 1318 1319static float _Complex 1320 _TG_ATTRS 1321 __tg_cproj(float _Complex __x) {return cprojf(__x);} 1322 1323static double _Complex 1324 _TG_ATTRS 1325 __tg_cproj(double _Complex __x) {return cproj(__x);} 1326 1327static 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 1336static float 1337 _TG_ATTRS 1338 __tg_creal(float __x) {return __x;} 1339 1340static double 1341 _TG_ATTRS 1342 __tg_creal(double __x) {return __x;} 1343 1344static long double 1345 _TG_ATTRS 1346 __tg_creal(long double __x) {return __x;} 1347 1348static float 1349 _TG_ATTRS 1350 __tg_creal(float _Complex __x) {return crealf(__x);} 1351 1352static double 1353 _TG_ATTRS 1354 __tg_creal(double _Complex __x) {return creal(__x);} 1355 1356static 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 */ 1369