1 /* 2 * ==================================================== 3 * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. 4 * 5 * Developed at SunPro, a Sun Microsystems, Inc. business. 6 * Permission to use, copy, modify, and distribute this 7 * software is freely granted, provided that this notice 8 * is preserved. 9 * ==================================================== 10 */ 11 12 /* 13 * from: @(#)fdlibm.h 5.1 93/09/24 14 * $FreeBSD$ 15 */ 16 17 #ifndef _MATH_PRIVATE_H_ 18 #define _MATH_PRIVATE_H_ 19 20 #include <sys/types.h> 21 #include <machine/endian.h> 22 23 /* 24 * The original fdlibm code used statements like: 25 * n0 = ((*(int*)&one)>>29)^1; * index of high word * 26 * ix0 = *(n0+(int*)&x); * high word of x * 27 * ix1 = *((1-n0)+(int*)&x); * low word of x * 28 * to dig two 32 bit words out of the 64 bit IEEE floating point 29 * value. That is non-ANSI, and, moreover, the gcc instruction 30 * scheduler gets it wrong. We instead use the following macros. 31 * Unlike the original code, we determine the endianness at compile 32 * time, not at run time; I don't see much benefit to selecting 33 * endianness at run time. 34 */ 35 36 /* 37 * A union which permits us to convert between a double and two 32 bit 38 * ints. 39 */ 40 41 #ifdef __arm__ 42 #if defined(__VFP_FP__) || defined(__ARM_EABI__) 43 #define IEEE_WORD_ORDER BYTE_ORDER 44 #else 45 #define IEEE_WORD_ORDER BIG_ENDIAN 46 #endif 47 #else /* __arm__ */ 48 #define IEEE_WORD_ORDER BYTE_ORDER 49 #endif 50 51 #if IEEE_WORD_ORDER == BIG_ENDIAN 52 53 typedef union 54 { 55 double value; 56 struct 57 { 58 u_int32_t msw; 59 u_int32_t lsw; 60 } parts; 61 struct 62 { 63 u_int64_t w; 64 } xparts; 65 } ieee_double_shape_type; 66 67 #endif 68 69 #if IEEE_WORD_ORDER == LITTLE_ENDIAN 70 71 typedef union 72 { 73 double value; 74 struct 75 { 76 u_int32_t lsw; 77 u_int32_t msw; 78 } parts; 79 struct 80 { 81 u_int64_t w; 82 } xparts; 83 } ieee_double_shape_type; 84 85 #endif 86 87 /* Get two 32 bit ints from a double. */ 88 89 #define EXTRACT_WORDS(ix0,ix1,d) \ 90 do { \ 91 ieee_double_shape_type ew_u; \ 92 ew_u.value = (d); \ 93 (ix0) = ew_u.parts.msw; \ 94 (ix1) = ew_u.parts.lsw; \ 95 } while (0) 96 97 /* Get a 64-bit int from a double. */ 98 #define EXTRACT_WORD64(ix,d) \ 99 do { \ 100 ieee_double_shape_type ew_u; \ 101 ew_u.value = (d); \ 102 (ix) = ew_u.xparts.w; \ 103 } while (0) 104 105 /* Get the more significant 32 bit int from a double. */ 106 107 #define GET_HIGH_WORD(i,d) \ 108 do { \ 109 ieee_double_shape_type gh_u; \ 110 gh_u.value = (d); \ 111 (i) = gh_u.parts.msw; \ 112 } while (0) 113 114 /* Get the less significant 32 bit int from a double. */ 115 116 #define GET_LOW_WORD(i,d) \ 117 do { \ 118 ieee_double_shape_type gl_u; \ 119 gl_u.value = (d); \ 120 (i) = gl_u.parts.lsw; \ 121 } while (0) 122 123 /* Set a double from two 32 bit ints. */ 124 125 #define INSERT_WORDS(d,ix0,ix1) \ 126 do { \ 127 ieee_double_shape_type iw_u; \ 128 iw_u.parts.msw = (ix0); \ 129 iw_u.parts.lsw = (ix1); \ 130 (d) = iw_u.value; \ 131 } while (0) 132 133 /* Set a double from a 64-bit int. */ 134 #define INSERT_WORD64(d,ix) \ 135 do { \ 136 ieee_double_shape_type iw_u; \ 137 iw_u.xparts.w = (ix); \ 138 (d) = iw_u.value; \ 139 } while (0) 140 141 /* Set the more significant 32 bits of a double from an int. */ 142 143 #define SET_HIGH_WORD(d,v) \ 144 do { \ 145 ieee_double_shape_type sh_u; \ 146 sh_u.value = (d); \ 147 sh_u.parts.msw = (v); \ 148 (d) = sh_u.value; \ 149 } while (0) 150 151 /* Set the less significant 32 bits of a double from an int. */ 152 153 #define SET_LOW_WORD(d,v) \ 154 do { \ 155 ieee_double_shape_type sl_u; \ 156 sl_u.value = (d); \ 157 sl_u.parts.lsw = (v); \ 158 (d) = sl_u.value; \ 159 } while (0) 160 161 /* 162 * A union which permits us to convert between a float and a 32 bit 163 * int. 164 */ 165 166 typedef union 167 { 168 float value; 169 /* FIXME: Assumes 32 bit int. */ 170 unsigned int word; 171 } ieee_float_shape_type; 172 173 /* Get a 32 bit int from a float. */ 174 175 #define GET_FLOAT_WORD(i,d) \ 176 do { \ 177 ieee_float_shape_type gf_u; \ 178 gf_u.value = (d); \ 179 (i) = gf_u.word; \ 180 } while (0) 181 182 /* Set a float from a 32 bit int. */ 183 184 #define SET_FLOAT_WORD(d,i) \ 185 do { \ 186 ieee_float_shape_type sf_u; \ 187 sf_u.word = (i); \ 188 (d) = sf_u.value; \ 189 } while (0) 190 191 /* 192 * Get expsign and mantissa as 16 bit and 64 bit ints from an 80 bit long 193 * double. 194 */ 195 196 #define EXTRACT_LDBL80_WORDS(ix0,ix1,d) \ 197 do { \ 198 union IEEEl2bits ew_u; \ 199 ew_u.e = (d); \ 200 (ix0) = ew_u.xbits.expsign; \ 201 (ix1) = ew_u.xbits.man; \ 202 } while (0) 203 204 /* 205 * Get expsign and mantissa as one 16 bit and two 64 bit ints from a 128 bit 206 * long double. 207 */ 208 209 #define EXTRACT_LDBL128_WORDS(ix0,ix1,ix2,d) \ 210 do { \ 211 union IEEEl2bits ew_u; \ 212 ew_u.e = (d); \ 213 (ix0) = ew_u.xbits.expsign; \ 214 (ix1) = ew_u.xbits.manh; \ 215 (ix2) = ew_u.xbits.manl; \ 216 } while (0) 217 218 /* Get expsign as a 16 bit int from a long double. */ 219 220 #define GET_LDBL_EXPSIGN(i,d) \ 221 do { \ 222 union IEEEl2bits ge_u; \ 223 ge_u.e = (d); \ 224 (i) = ge_u.xbits.expsign; \ 225 } while (0) 226 227 /* 228 * Set an 80 bit long double from a 16 bit int expsign and a 64 bit int 229 * mantissa. 230 */ 231 232 #define INSERT_LDBL80_WORDS(d,ix0,ix1) \ 233 do { \ 234 union IEEEl2bits iw_u; \ 235 iw_u.xbits.expsign = (ix0); \ 236 iw_u.xbits.man = (ix1); \ 237 (d) = iw_u.e; \ 238 } while (0) 239 240 /* 241 * Set a 128 bit long double from a 16 bit int expsign and two 64 bit ints 242 * comprising the mantissa. 243 */ 244 245 #define INSERT_LDBL128_WORDS(d,ix0,ix1,ix2) \ 246 do { \ 247 union IEEEl2bits iw_u; \ 248 iw_u.xbits.expsign = (ix0); \ 249 iw_u.xbits.manh = (ix1); \ 250 iw_u.xbits.manl = (ix2); \ 251 (d) = iw_u.e; \ 252 } while (0) 253 254 /* Set expsign of a long double from a 16 bit int. */ 255 256 #define SET_LDBL_EXPSIGN(d,v) \ 257 do { \ 258 union IEEEl2bits se_u; \ 259 se_u.e = (d); \ 260 se_u.xbits.expsign = (v); \ 261 (d) = se_u.e; \ 262 } while (0) 263 264 #ifdef __i386__ 265 /* Long double constants are broken on i386. */ 266 #define LD80C(m, ex, v) { \ 267 .xbits.man = __CONCAT(m, ULL), \ 268 .xbits.expsign = (0x3fff + (ex)) | ((v) < 0 ? 0x8000 : 0), \ 269 } 270 #else 271 /* The above works on non-i386 too, but we use this to check v. */ 272 #define LD80C(m, ex, v) { .e = (v), } 273 #endif 274 275 #ifdef FLT_EVAL_METHOD 276 /* 277 * Attempt to get strict C99 semantics for assignment with non-C99 compilers. 278 */ 279 #if FLT_EVAL_METHOD == 0 || __GNUC__ == 0 280 #define STRICT_ASSIGN(type, lval, rval) ((lval) = (rval)) 281 #else 282 #define STRICT_ASSIGN(type, lval, rval) do { \ 283 volatile type __lval; \ 284 \ 285 if (sizeof(type) >= sizeof(long double)) \ 286 (lval) = (rval); \ 287 else { \ 288 __lval = (rval); \ 289 (lval) = __lval; \ 290 } \ 291 } while (0) 292 #endif 293 #endif /* FLT_EVAL_METHOD */ 294 295 /* Support switching the mode to FP_PE if necessary. */ 296 #if defined(__i386__) && !defined(NO_FPSETPREC) 297 #define ENTERI() \ 298 long double __retval; \ 299 fp_prec_t __oprec; \ 300 \ 301 if ((__oprec = fpgetprec()) != FP_PE) \ 302 fpsetprec(FP_PE) 303 #define RETURNI(x) do { \ 304 __retval = (x); \ 305 if (__oprec != FP_PE) \ 306 fpsetprec(__oprec); \ 307 RETURNF(__retval); \ 308 } while (0) 309 #else 310 #define ENTERI(x) 311 #define RETURNI(x) RETURNF(x) 312 #endif 313 314 /* Default return statement if hack*_t() is not used. */ 315 #define RETURNF(v) return (v) 316 317 /* 318 * 2sum gives the same result as 2sumF without requiring |a| >= |b| or 319 * a == 0, but is slower. 320 */ 321 #define _2sum(a, b) do { \ 322 __typeof(a) __s, __w; \ 323 \ 324 __w = (a) + (b); \ 325 __s = __w - (a); \ 326 (b) = ((a) - (__w - __s)) + ((b) - __s); \ 327 (a) = __w; \ 328 } while (0) 329 330 /* 331 * 2sumF algorithm. 332 * 333 * "Normalize" the terms in the infinite-precision expression a + b for 334 * the sum of 2 floating point values so that b is as small as possible 335 * relative to 'a'. (The resulting 'a' is the value of the expression in 336 * the same precision as 'a' and the resulting b is the rounding error.) 337 * |a| must be >= |b| or 0, b's type must be no larger than 'a's type, and 338 * exponent overflow or underflow must not occur. This uses a Theorem of 339 * Dekker (1971). See Knuth (1981) 4.2.2 Theorem C. The name "TwoSum" 340 * is apparently due to Skewchuk (1997). 341 * 342 * For this to always work, assignment of a + b to 'a' must not retain any 343 * extra precision in a + b. This is required by C standards but broken 344 * in many compilers. The brokenness cannot be worked around using 345 * STRICT_ASSIGN() like we do elsewhere, since the efficiency of this 346 * algorithm would be destroyed by non-null strict assignments. (The 347 * compilers are correct to be broken -- the efficiency of all floating 348 * point code calculations would be destroyed similarly if they forced the 349 * conversions.) 350 * 351 * Fortunately, a case that works well can usually be arranged by building 352 * any extra precision into the type of 'a' -- 'a' should have type float_t, 353 * double_t or long double. b's type should be no larger than 'a's type. 354 * Callers should use these types with scopes as large as possible, to 355 * reduce their own extra-precision and efficiciency problems. In 356 * particular, they shouldn't convert back and forth just to call here. 357 */ 358 #ifdef DEBUG 359 #define _2sumF(a, b) do { \ 360 __typeof(a) __w; \ 361 volatile __typeof(a) __ia, __ib, __r, __vw; \ 362 \ 363 __ia = (a); \ 364 __ib = (b); \ 365 assert(__ia == 0 || fabsl(__ia) >= fabsl(__ib)); \ 366 \ 367 __w = (a) + (b); \ 368 (b) = ((a) - __w) + (b); \ 369 (a) = __w; \ 370 \ 371 /* The next 2 assertions are weak if (a) is already long double. */ \ 372 assert((long double)__ia + __ib == (long double)(a) + (b)); \ 373 __vw = __ia + __ib; \ 374 __r = __ia - __vw; \ 375 __r += __ib; \ 376 assert(__vw == (a) && __r == (b)); \ 377 } while (0) 378 #else /* !DEBUG */ 379 #define _2sumF(a, b) do { \ 380 __typeof(a) __w; \ 381 \ 382 __w = (a) + (b); \ 383 (b) = ((a) - __w) + (b); \ 384 (a) = __w; \ 385 } while (0) 386 #endif /* DEBUG */ 387 388 /* 389 * Set x += c, where x is represented in extra precision as a + b. 390 * x must be sufficiently normalized and sufficiently larger than c, 391 * and the result is then sufficiently normalized. 392 * 393 * The details of ordering are that |a| must be >= |c| (so that (a, c) 394 * can be normalized without extra work to swap 'a' with c). The details of 395 * the normalization are that b must be small relative to the normalized 'a'. 396 * Normalization of (a, c) makes the normalized c tiny relative to the 397 * normalized a, so b remains small relative to 'a' in the result. However, 398 * b need not ever be tiny relative to 'a'. For example, b might be about 399 * 2**20 times smaller than 'a' to give about 20 extra bits of precision. 400 * That is usually enough, and adding c (which by normalization is about 401 * 2**53 times smaller than a) cannot change b significantly. However, 402 * cancellation of 'a' with c in normalization of (a, c) may reduce 'a' 403 * significantly relative to b. The caller must ensure that significant 404 * cancellation doesn't occur, either by having c of the same sign as 'a', 405 * or by having |c| a few percent smaller than |a|. Pre-normalization of 406 * (a, b) may help. 407 * 408 * This is is a variant of an algorithm of Kahan (see Knuth (1981) 4.2.2 409 * exercise 19). We gain considerable efficiency by requiring the terms to 410 * be sufficiently normalized and sufficiently increasing. 411 */ 412 #define _3sumF(a, b, c) do { \ 413 __typeof(a) __tmp; \ 414 \ 415 __tmp = (c); \ 416 _2sumF(__tmp, (a)); \ 417 (b) += (a); \ 418 (a) = __tmp; \ 419 } while (0) 420 421 /* 422 * Common routine to process the arguments to nan(), nanf(), and nanl(). 423 */ 424 void _scan_nan(uint32_t *__words, int __num_words, const char *__s); 425 426 #ifdef _COMPLEX_H 427 428 /* 429 * C99 specifies that complex numbers have the same representation as 430 * an array of two elements, where the first element is the real part 431 * and the second element is the imaginary part. 432 */ 433 typedef union { 434 float complex f; 435 float a[2]; 436 } float_complex; 437 typedef union { 438 double complex f; 439 double a[2]; 440 } double_complex; 441 typedef union { 442 long double complex f; 443 long double a[2]; 444 } long_double_complex; 445 #define REALPART(z) ((z).a[0]) 446 #define IMAGPART(z) ((z).a[1]) 447 448 /* 449 * Inline functions that can be used to construct complex values. 450 * 451 * The C99 standard intends x+I*y to be used for this, but x+I*y is 452 * currently unusable in general since gcc introduces many overflow, 453 * underflow, sign and efficiency bugs by rewriting I*y as 454 * (0.0+I)*(y+0.0*I) and laboriously computing the full complex product. 455 * In particular, I*Inf is corrupted to NaN+I*Inf, and I*-0 is corrupted 456 * to -0.0+I*0.0. 457 * 458 * The C11 standard introduced the macros CMPLX(), CMPLXF() and CMPLXL() 459 * to construct complex values. Compilers that conform to the C99 460 * standard require the following functions to avoid the above issues. 461 */ 462 463 #ifndef CMPLXF 464 static __inline float complex 465 CMPLXF(float x, float y) 466 { 467 float_complex z; 468 469 REALPART(z) = x; 470 IMAGPART(z) = y; 471 return (z.f); 472 } 473 #endif 474 475 #ifndef CMPLX 476 static __inline double complex 477 CMPLX(double x, double y) 478 { 479 double_complex z; 480 481 REALPART(z) = x; 482 IMAGPART(z) = y; 483 return (z.f); 484 } 485 #endif 486 487 #ifndef CMPLXL 488 static __inline long double complex 489 CMPLXL(long double x, long double y) 490 { 491 long_double_complex z; 492 493 REALPART(z) = x; 494 IMAGPART(z) = y; 495 return (z.f); 496 } 497 #endif 498 499 #endif /* _COMPLEX_H */ 500 501 #ifdef __GNUCLIKE_ASM 502 503 /* Asm versions of some functions. */ 504 505 #ifdef __amd64__ 506 static __inline int 507 irint(double x) 508 { 509 int n; 510 511 asm("cvtsd2si %1,%0" : "=r" (n) : "x" (x)); 512 return (n); 513 } 514 #define HAVE_EFFICIENT_IRINT 515 #endif 516 517 #ifdef __i386__ 518 static __inline int 519 irint(double x) 520 { 521 int n; 522 523 asm("fistl %0" : "=m" (n) : "t" (x)); 524 return (n); 525 } 526 #define HAVE_EFFICIENT_IRINT 527 #endif 528 529 #if defined(__amd64__) || defined(__i386__) 530 static __inline int 531 irintl(long double x) 532 { 533 int n; 534 535 asm("fistl %0" : "=m" (n) : "t" (x)); 536 return (n); 537 } 538 #define HAVE_EFFICIENT_IRINTL 539 #endif 540 541 #endif /* __GNUCLIKE_ASM */ 542 543 #ifdef DEBUG 544 #if defined(__amd64__) || defined(__i386__) 545 #define breakpoint() asm("int $3") 546 #else 547 #include <signal.h> 548 549 #define breakpoint() raise(SIGTRAP) 550 #endif 551 #endif 552 553 /* Write a pari script to test things externally. */ 554 #ifdef DOPRINT 555 #include <stdio.h> 556 557 #ifndef DOPRINT_SWIZZLE 558 #define DOPRINT_SWIZZLE 0 559 #endif 560 561 #ifdef DOPRINT_LD80 562 563 #define DOPRINT_START(xp) do { \ 564 uint64_t __lx; \ 565 uint16_t __hx; \ 566 \ 567 /* Hack to give more-problematic args. */ \ 568 EXTRACT_LDBL80_WORDS(__hx, __lx, *xp); \ 569 __lx ^= DOPRINT_SWIZZLE; \ 570 INSERT_LDBL80_WORDS(*xp, __hx, __lx); \ 571 printf("x = %.21Lg; ", (long double)*xp); \ 572 } while (0) 573 #define DOPRINT_END1(v) \ 574 printf("y = %.21Lg; z = 0; show(x, y, z);\n", (long double)(v)) 575 #define DOPRINT_END2(hi, lo) \ 576 printf("y = %.21Lg; z = %.21Lg; show(x, y, z);\n", \ 577 (long double)(hi), (long double)(lo)) 578 579 #elif defined(DOPRINT_D64) 580 581 #define DOPRINT_START(xp) do { \ 582 uint32_t __hx, __lx; \ 583 \ 584 EXTRACT_WORDS(__hx, __lx, *xp); \ 585 __lx ^= DOPRINT_SWIZZLE; \ 586 INSERT_WORDS(*xp, __hx, __lx); \ 587 printf("x = %.21Lg; ", (long double)*xp); \ 588 } while (0) 589 #define DOPRINT_END1(v) \ 590 printf("y = %.21Lg; z = 0; show(x, y, z);\n", (long double)(v)) 591 #define DOPRINT_END2(hi, lo) \ 592 printf("y = %.21Lg; z = %.21Lg; show(x, y, z);\n", \ 593 (long double)(hi), (long double)(lo)) 594 595 #elif defined(DOPRINT_F32) 596 597 #define DOPRINT_START(xp) do { \ 598 uint32_t __hx; \ 599 \ 600 GET_FLOAT_WORD(__hx, *xp); \ 601 __hx ^= DOPRINT_SWIZZLE; \ 602 SET_FLOAT_WORD(*xp, __hx); \ 603 printf("x = %.21Lg; ", (long double)*xp); \ 604 } while (0) 605 #define DOPRINT_END1(v) \ 606 printf("y = %.21Lg; z = 0; show(x, y, z);\n", (long double)(v)) 607 #define DOPRINT_END2(hi, lo) \ 608 printf("y = %.21Lg; z = %.21Lg; show(x, y, z);\n", \ 609 (long double)(hi), (long double)(lo)) 610 611 #else /* !DOPRINT_LD80 && !DOPRINT_D64 (LD128 only) */ 612 613 #ifndef DOPRINT_SWIZZLE_HIGH 614 #define DOPRINT_SWIZZLE_HIGH 0 615 #endif 616 617 #define DOPRINT_START(xp) do { \ 618 uint64_t __lx, __llx; \ 619 uint16_t __hx; \ 620 \ 621 EXTRACT_LDBL128_WORDS(__hx, __lx, __llx, *xp); \ 622 __llx ^= DOPRINT_SWIZZLE; \ 623 __lx ^= DOPRINT_SWIZZLE_HIGH; \ 624 INSERT_LDBL128_WORDS(*xp, __hx, __lx, __llx); \ 625 printf("x = %.36Lg; ", (long double)*xp); \ 626 } while (0) 627 #define DOPRINT_END1(v) \ 628 printf("y = %.36Lg; z = 0; show(x, y, z);\n", (long double)(v)) 629 #define DOPRINT_END2(hi, lo) \ 630 printf("y = %.36Lg; z = %.36Lg; show(x, y, z);\n", \ 631 (long double)(hi), (long double)(lo)) 632 633 #endif /* DOPRINT_LD80 */ 634 635 #else /* !DOPRINT */ 636 #define DOPRINT_START(xp) 637 #define DOPRINT_END1(v) 638 #define DOPRINT_END2(hi, lo) 639 #endif /* DOPRINT */ 640 641 #define RETURNP(x) do { \ 642 DOPRINT_END1(x); \ 643 RETURNF(x); \ 644 } while (0) 645 #define RETURNPI(x) do { \ 646 DOPRINT_END1(x); \ 647 RETURNI(x); \ 648 } while (0) 649 #define RETURN2P(x, y) do { \ 650 DOPRINT_END2((x), (y)); \ 651 RETURNF((x) + (y)); \ 652 } while (0) 653 #define RETURN2PI(x, y) do { \ 654 DOPRINT_END2((x), (y)); \ 655 RETURNI((x) + (y)); \ 656 } while (0) 657 #ifdef STRUCT_RETURN 658 #define RETURNSP(rp) do { \ 659 if (!(rp)->lo_set) \ 660 RETURNP((rp)->hi); \ 661 RETURN2P((rp)->hi, (rp)->lo); \ 662 } while (0) 663 #define RETURNSPI(rp) do { \ 664 if (!(rp)->lo_set) \ 665 RETURNPI((rp)->hi); \ 666 RETURN2PI((rp)->hi, (rp)->lo); \ 667 } while (0) 668 #endif 669 #define SUM2P(x, y) ({ \ 670 const __typeof (x) __x = (x); \ 671 const __typeof (y) __y = (y); \ 672 \ 673 DOPRINT_END2(__x, __y); \ 674 __x + __y; \ 675 }) 676 677 /* 678 * ieee style elementary functions 679 * 680 * We rename functions here to improve other sources' diffability 681 * against fdlibm. 682 */ 683 #define __ieee754_sqrt sqrt 684 #define __ieee754_acos acos 685 #define __ieee754_acosh acosh 686 #define __ieee754_log log 687 #define __ieee754_log2 log2 688 #define __ieee754_atanh atanh 689 #define __ieee754_asin asin 690 #define __ieee754_atan2 atan2 691 #define __ieee754_exp exp 692 #define __ieee754_cosh cosh 693 #define __ieee754_fmod fmod 694 #define __ieee754_pow pow 695 #define __ieee754_lgamma lgamma 696 #define __ieee754_gamma gamma 697 #define __ieee754_lgamma_r lgamma_r 698 #define __ieee754_gamma_r gamma_r 699 #define __ieee754_log10 log10 700 #define __ieee754_sinh sinh 701 #define __ieee754_hypot hypot 702 #define __ieee754_j0 j0 703 #define __ieee754_j1 j1 704 #define __ieee754_y0 y0 705 #define __ieee754_y1 y1 706 #define __ieee754_jn jn 707 #define __ieee754_yn yn 708 #define __ieee754_remainder remainder 709 #define __ieee754_scalb scalb 710 #define __ieee754_sqrtf sqrtf 711 #define __ieee754_acosf acosf 712 #define __ieee754_acoshf acoshf 713 #define __ieee754_logf logf 714 #define __ieee754_atanhf atanhf 715 #define __ieee754_asinf asinf 716 #define __ieee754_atan2f atan2f 717 #define __ieee754_expf expf 718 #define __ieee754_coshf coshf 719 #define __ieee754_fmodf fmodf 720 #define __ieee754_powf powf 721 #define __ieee754_lgammaf lgammaf 722 #define __ieee754_gammaf gammaf 723 #define __ieee754_lgammaf_r lgammaf_r 724 #define __ieee754_gammaf_r gammaf_r 725 #define __ieee754_log10f log10f 726 #define __ieee754_log2f log2f 727 #define __ieee754_sinhf sinhf 728 #define __ieee754_hypotf hypotf 729 #define __ieee754_j0f j0f 730 #define __ieee754_j1f j1f 731 #define __ieee754_y0f y0f 732 #define __ieee754_y1f y1f 733 #define __ieee754_jnf jnf 734 #define __ieee754_ynf ynf 735 #define __ieee754_remainderf remainderf 736 #define __ieee754_scalbf scalbf 737 738 /* fdlibm kernel function */ 739 int __kernel_rem_pio2(double*,double*,int,int,int); 740 741 /* double precision kernel functions */ 742 #ifndef INLINE_REM_PIO2 743 int __ieee754_rem_pio2(double,double*); 744 #endif 745 double __kernel_sin(double,double,int); 746 double __kernel_cos(double,double); 747 double __kernel_tan(double,double,int); 748 double __ldexp_exp(double,int); 749 #ifdef _COMPLEX_H 750 double complex __ldexp_cexp(double complex,int); 751 #endif 752 753 /* float precision kernel functions */ 754 #ifndef INLINE_REM_PIO2F 755 int __ieee754_rem_pio2f(float,double*); 756 #endif 757 #ifndef INLINE_KERNEL_SINDF 758 float __kernel_sindf(double); 759 #endif 760 #ifndef INLINE_KERNEL_COSDF 761 float __kernel_cosdf(double); 762 #endif 763 #ifndef INLINE_KERNEL_TANDF 764 float __kernel_tandf(double,int); 765 #endif 766 float __ldexp_expf(float,int); 767 #ifdef _COMPLEX_H 768 float complex __ldexp_cexpf(float complex,int); 769 #endif 770 771 /* long double precision kernel functions */ 772 long double __kernel_sinl(long double, long double, int); 773 long double __kernel_cosl(long double, long double); 774 long double __kernel_tanl(long double, long double, int); 775 776 #endif /* !_MATH_PRIVATE_H_ */ 777