1 /** 2 * D header file for C99. 3 * 4 * $(C_HEADER_DESCRIPTION pubs.opengroup.org/onlinepubs/009695399/basedefs/_math.h.html, _math.h) 5 * 6 * Copyright: Copyright Sean Kelly 2005 - 2012. 7 * License: Distributed under the 8 * $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost Software License 1.0). 9 * (See accompanying file LICENSE) 10 * Authors: Sean Kelly 11 * Source: $(DRUNTIMESRC core/stdc/_math.d) 12 */ 13 14 module core.stdc.math; 15 16 import core.stdc.config; 17 18 version (OSX) 19 version = Darwin; 20 else version (iOS) 21 version = Darwin; 22 else version (TVOS) 23 version = Darwin; 24 else version (WatchOS) 25 version = Darwin; 26 27 version (ARM) version = ARM_Any; 28 version (AArch64) version = ARM_Any; 29 version (HPPA) version = HPPA_Any; 30 version (MIPS32) version = MIPS_Any; 31 version (MIPS64) version = MIPS_Any; 32 version (PPC) version = PPC_Any; 33 version (PPC64) version = PPC_Any; 34 version (RISCV32) version = RISCV_Any; 35 version (RISCV64) version = RISCV_Any; 36 version (S390) version = IBMZ_Any; 37 version (SPARC) version = SPARC_Any; 38 version (SPARC64) version = SPARC_Any; 39 version (SystemZ) version = IBMZ_Any; 40 version (X86) version = X86_Any; 41 version (X86_64) version = X86_Any; 42 43 extern (C): 44 @trusted: // All functions here operate on floating point and integer values only. 45 nothrow: 46 @nogc: 47 48 /// 49 alias float float_t; 50 /// 51 alias double double_t; 52 53 /// 54 enum double HUGE_VAL = double.infinity; 55 /// 56 enum double HUGE_VALF = float.infinity; 57 /// 58 enum double HUGE_VALL = real.infinity; 59 60 /// 61 enum float INFINITY = float.infinity; 62 /// 63 enum float NAN = float.nan; 64 65 version (FreeBSD) 66 { 67 /// 68 enum int FP_ILOGB0 = -int.max; 69 /// 70 enum int FP_ILOGBNAN = int.max; 71 } 72 else version (NetBSD) 73 { 74 /// 75 enum int FP_ILOGB0 = -int.max; 76 /// 77 enum int FP_ILOGBNAN = int.max; 78 } 79 else version (OpenBSD) 80 { 81 /// 82 enum int FP_ILOGB0 = -int.max; 83 /// 84 enum int FP_ILOGBNAN = int.max; 85 } 86 else version (DragonFlyBSD) 87 { 88 /// 89 enum int FP_ILOGB0 = -int.max; 90 /// 91 enum int FP_ILOGBNAN = int.max; 92 } 93 else version (Solaris) 94 { 95 /// 96 enum int FP_ILOGB0 = -int.max; 97 /// 98 enum int FP_ILOGBNAN = int.max; 99 } 100 else version (CRuntime_Bionic) 101 { 102 /// 103 enum int FP_ILOGB0 = -int.max; 104 /// 105 enum int FP_ILOGBNAN = int.max; 106 } 107 else version (CRuntime_UClibc) 108 { 109 version (X86_Any) 110 { 111 /// 112 enum int FP_ILOGB0 = int.min; 113 /// 114 enum int FP_ILOGBNAN = int.min; 115 } 116 else version (MIPS_Any) 117 { 118 /// 119 enum int FP_ILOGB0 = -int.max; 120 /// 121 enum int FP_ILOGBNAN = int.max; 122 } 123 else version (ARM) 124 { 125 /// 126 enum int FP_ILOGB0 = -int.max; 127 /// 128 enum int FP_ILOGBNAN = int.max; 129 } 130 else 131 { 132 static assert(false, "Architecture not supported."); 133 } 134 } 135 else version (CRuntime_Glibc) 136 { 137 version (X86_Any) 138 { 139 /// 140 enum int FP_ILOGB0 = int.min; 141 /// 142 enum int FP_ILOGBNAN = int.min; 143 } 144 else version (ARM_Any) 145 { 146 /// 147 enum int FP_ILOGB0 = -int.max; 148 /// 149 enum int FP_ILOGBNAN = int.max; 150 } 151 else version (HPPA_Any) 152 { 153 /// 154 enum int FP_ILOGB0 = -int.max; 155 /// 156 enum int FP_ILOGBNAN = int.max; 157 } 158 else version (MIPS_Any) 159 { 160 /// 161 enum int FP_ILOGB0 = -int.max; 162 /// 163 enum int FP_ILOGBNAN = int.max; 164 } 165 else version (PPC_Any) 166 { 167 /// 168 enum int FP_ILOGB0 = -int.max; 169 /// 170 enum int FP_ILOGBNAN = int.max; 171 } 172 else version (RISCV_Any) 173 { 174 /// 175 enum int FP_ILOGB0 = -int.max; 176 /// 177 enum int FP_ILOGBNAN = int.max; 178 } 179 else version (SPARC_Any) 180 { 181 /// 182 enum int FP_ILOGB0 = -int.max; 183 /// 184 enum int FP_ILOGBNAN = int.max; 185 } 186 else version (IBMZ_Any) 187 { 188 /// 189 enum int FP_ILOGB0 = -int.max; 190 /// 191 enum int FP_ILOGBNAN = int.max; 192 } 193 else version (LoongArch64) 194 { 195 /// 196 enum int FP_ILOGB0 = -int.max; 197 /// 198 enum int FP_ILOGBNAN = int.max; 199 } 200 else 201 { 202 static assert(false, "Architecture not supported."); 203 } 204 } 205 else 206 { 207 /// 208 enum int FP_ILOGB0 = int.min; 209 /// 210 enum int FP_ILOGBNAN = int.min; 211 } 212 213 /// 214 enum int MATH_ERRNO = 1; 215 /// 216 enum int MATH_ERREXCEPT = 2; 217 /// 218 enum int math_errhandling = MATH_ERRNO | MATH_ERREXCEPT; 219 220 version (none) 221 { 222 // 223 // these functions are all macros in C 224 // 225 226 //int fpclassify(real-floating x); 227 pure int fpclassify(float x); 228 pure int fpclassify(double x); 229 pure int fpclassify(real x); 230 231 //int isfinite(real-floating x); 232 pure int isfinite(float x); 233 pure int isfinite(double x); 234 pure int isfinite(real x); 235 236 //int isinf(real-floating x); 237 pure int isinf(float x); 238 pure int isinf(double x); 239 pure int isinf(real x); 240 241 //int isnan(real-floating x); 242 pure int isnan(float x); 243 pure int isnan(double x); 244 pure int isnan(real x); 245 246 //int isnormal(real-floating x); 247 pure int isnormal(float x); 248 pure int isnormal(double x); 249 pure int isnormal(real x); 250 251 //int signbit(real-floating x); 252 pure int signbit(float x); 253 pure int signbit(double x); 254 pure int signbit(real x); 255 256 //int isgreater(real-floating x, real-floating y); 257 pure int isgreater(float x, float y); 258 pure int isgreater(double x, double y); 259 pure int isgreater(real x, real y); 260 261 //int isgreaterequal(real-floating x, real-floating y); 262 pure int isgreaterequal(float x, float y); 263 pure int isgreaterequal(double x, double y); 264 pure int isgreaterequal(real x, real y); 265 266 //int isless(real-floating x, real-floating y); 267 pure int isless(float x, float y); 268 pure int isless(double x, double y); 269 pure int isless(real x, real y); 270 271 //int islessequal(real-floating x, real-floating y); 272 pure int islessequal(float x, float y); 273 pure int islessequal(double x, double y); 274 pure int islessequal(real x, real y); 275 276 //int islessgreater(real-floating x, real-floating y); 277 pure int islessgreater(float x, float y); 278 pure int islessgreater(double x, double y); 279 pure int islessgreater(real x, real y); 280 281 //int isunordered(real-floating x, real-floating y); 282 pure int isunordered(float x, float y); 283 pure int isunordered(double x, double y); 284 pure int isunordered(real x, real y); 285 } 286 287 version (CRuntime_DigitalMars) 288 { 289 enum 290 { 291 /// 292 FP_NANS = 0, 293 /// 294 FP_NANQ = 1, 295 /// 296 FP_INFINITE = 2, 297 /// 298 FP_NORMAL = 3, 299 /// 300 FP_SUBNORMAL = 4, 301 /// 302 FP_ZERO = 5, 303 /// 304 FP_NAN = FP_NANQ, 305 /// 306 FP_EMPTY = 6, 307 /// 308 FP_UNSUPPORTED = 7, 309 } 310 311 enum 312 { 313 /// 314 FP_FAST_FMA = 0, 315 /// 316 FP_FAST_FMAF = 0, 317 /// 318 FP_FAST_FMAL = 0, 319 } 320 321 pure uint __fpclassify_f(float x); 322 pure uint __fpclassify_d(double x); 323 pure uint __fpclassify_ld(real x); 324 325 //int fpclassify(real-floating x); 326 /// 327 pragma(mangle, "__fpclassify_f") pure int fpclassify(float x); 328 /// 329 pragma(mangle, "__fpclassify_d") pure int fpclassify(double x); 330 /// 331 pragma(mangle, real.sizeof == double.sizeof ? "__fpclassify_d" : "__fpclassify_ld") 332 pure int fpclassify(real x); 333 334 extern (D) 335 { 336 //int isfinite(real-floating x); 337 /// 338 pure int isfinite(float x) { return fpclassify(x) >= FP_NORMAL; } 339 /// 340 pure int isfinite(double x) { return fpclassify(x) >= FP_NORMAL; } 341 /// 342 pure int isfinite(real x) { return fpclassify(x) >= FP_NORMAL; } 343 344 //int isinf(real-floating x); 345 /// 346 pure int isinf(float x) { return fpclassify(x) == FP_INFINITE; } 347 /// 348 pure int isinf(double x) { return fpclassify(x) == FP_INFINITE; } 349 /// 350 pure int isinf(real x) { return fpclassify(x) == FP_INFINITE; } 351 352 //int isnan(real-floating x); 353 /// 354 pure int isnan(float x) { return fpclassify(x) <= FP_NANQ; } 355 /// 356 pure int isnan(double x) { return fpclassify(x) <= FP_NANQ; } 357 /// 358 pure int isnan(real x) { return fpclassify(x) <= FP_NANQ; } 359 360 //int isnormal(real-floating x); 361 /// 362 pure int isnormal(float x) { return fpclassify(x) == FP_NORMAL; } 363 /// 364 pure int isnormal(double x) { return fpclassify(x) == FP_NORMAL; } 365 /// 366 pure int isnormal(real x) { return fpclassify(x) == FP_NORMAL; } 367 368 //int signbit(real-floating x); 369 /// 370 pure int signbit(float x) { return (cast(short*)&(x))[1] & 0x8000; } 371 /// 372 pure int signbit(double x) { return (cast(short*)&(x))[3] & 0x8000; } 373 /// 374 pure int signbit(real x) 375 { 376 return (real.sizeof == double.sizeof) 377 ? (cast(short*)&(x))[3] & 0x8000 378 : (cast(short*)&(x))[4] & 0x8000; 379 } 380 } 381 } 382 else version (CRuntime_Microsoft) // fully supported since MSVCRT 12 (VS 2013) only 383 { 384 version (all) // legacy stuff to be removed in the future 385 { 386 enum 387 { 388 _FPCLASS_SNAN = 1, 389 _FPCLASS_QNAN = 2, 390 _FPCLASS_NINF = 4, 391 _FPCLASS_NN = 8, 392 _FPCLASS_ND = 0x10, 393 _FPCLASS_NZ = 0x20, 394 _FPCLASS_PZ = 0x40, 395 _FPCLASS_PD = 0x80, 396 _FPCLASS_PN = 0x100, 397 _FPCLASS_PINF = 0x200, 398 } 399 400 //deprecated("Please use the standard C99 function copysignf() instead.") 401 pure float _copysignf(float x, float s); 402 403 //deprecated("_chgsignf(x) is a non-standard MS extension. Please consider using -x instead.") 404 pure float _chgsignf(float x); 405 406 version (Win64) // not available in 32-bit runtimes 407 { 408 //deprecated("Please use the standard C99 function isfinite() instead.") 409 pure int _finitef(float x); 410 411 //deprecated("Please use the standard C99 function isnan() instead.") 412 pure int _isnanf(float x); 413 414 //deprecated("Please use the standard C99 function fpclassify() instead.") 415 pure int _fpclassf(float x); 416 } 417 418 //deprecated("Please use the standard C99 function copysign() instead.") 419 pure double _copysign(double x, double s); 420 421 //deprecated("_chgsign(x) is a non-standard MS extension. Please consider using -x instead.") 422 pure double _chgsign(double x); 423 424 //deprecated("Please use the standard C99 function isfinite() instead.") 425 pure int _finite(double x); 426 427 //deprecated("Please use the standard C99 function isnan() instead.") 428 pure int _isnan(double x); 429 430 //deprecated("Please use the standard C99 function fpclassify() instead.") 431 pure int _fpclass(double x); 432 } 433 434 version (MinGW) 435 { 436 enum 437 { 438 /// 439 FP_NAN = 0x0100, 440 /// 441 FP_NORMAL = 0x0400, 442 /// 443 FP_INFINITE = FP_NAN | FP_NORMAL, 444 /// 445 FP_ZERO = 0x0400, 446 /// 447 FP_SUBNORMAL = FP_NORMAL | FP_ZERO 448 } 449 450 pure int __fpclassifyf(float x); 451 pure int __fpclassify(double x); 452 pure int __fpclassifyl(real x); 453 454 pure int __isnanf(float x); 455 pure int __isnan(double x); 456 pure int __isnanl(real x); 457 458 pure int __signbitf(float x); 459 pure int __signbit(double x); 460 pure int __signbitl(real x); 461 462 //int fpclassify(real-floating x); 463 /// 464 pragma(mangle, "__fpclassifyf") pure int fpclassify(float x); 465 /// 466 pragma(mangle, "__fpclassify") pure int fpclassify(double x); 467 /// 468 pragma(mangle, real.sizeof == double.sizeof ? "__fpclassify" : "__fpclassifyl") 469 pure int fpclassify(real x); 470 471 extern (D) 472 { 473 //int isfinite(real-floating x); 474 /// 475 pure int isfinite(float x) { return (fpclassify(x) & FP_NORMAL) == 0; } 476 /// 477 pure int isfinite(double x) { return (fpclassify(x) & FP_NORMAL) == 0; } 478 /// 479 pure int isfinite(real x) { return (fpclassify(x) & FP_NORMAL) == 0; } 480 481 //int isinf(real-floating x); 482 /// 483 pure int isinf(float x) { return fpclassify(x) == FP_INFINITE; } 484 /// 485 pure int isinf(double x) { return fpclassify(x) == FP_INFINITE; } 486 /// 487 pure int isinf(real x) { return fpclassify(x) == FP_INFINITE; } 488 } 489 490 //int isnan(real-floating x); 491 /// 492 pragma(mangle, "__isnanf") pure int isnan(float x); 493 /// 494 pragma(mangle, "__isnan") pure int isnan(double x); 495 /// 496 pragma(mangle, real.sizeof == double.sizeof ? "__isnan" : "__isnanl") 497 pure int isnan(real x); 498 499 extern (D) 500 { 501 //int isnormal(real-floating x); 502 /// 503 int isnormal(float x) { return fpclassify(x) == FP_NORMAL; } 504 /// 505 int isnormal(double x) { return fpclassify(x) == FP_NORMAL; } 506 /// 507 int isnormal(real x) { return fpclassify(x) == FP_NORMAL; } 508 } 509 510 //int signbit(real-floating x); 511 /// 512 pragma(mangle, "__signbitf") pure int signbit(float x); 513 /// 514 pragma(mangle, "__signbit") pure int signbit(double x); 515 /// 516 pragma(mangle, real.sizeof == double.sizeof ? "__signbit" : "__signbitl") 517 int signbit(real x); 518 } 519 else 520 { 521 enum 522 { 523 /// 524 FP_SUBNORMAL = -2, 525 /// 526 FP_NORMAL = -1, 527 /// 528 FP_ZERO = 0, 529 /// 530 FP_INFINITE = 1, 531 /// 532 FP_NAN = 2, 533 } 534 535 extern(D) 536 { 537 //int fpclassify(real-floating x); 538 /// 539 extern(C) pragma(mangle, "_fdclass") pure int fpclassify(float x); 540 /// 541 extern(C) pragma(mangle, "_dclass") pure int fpclassify(double x); 542 /// 543 pure int fpclassify()(real x) 544 { 545 static if (real.sizeof == double.sizeof) 546 return fpclassify(cast(double) x); 547 else 548 static assert(false, "fpclassify(real) not supported by MS C runtime"); 549 } 550 551 //int isfinite(real-floating x); 552 /// 553 pure int isfinite()(float x) { return fpclassify(x) <= 0; } 554 /// 555 pure int isfinite()(double x) { return fpclassify(x) <= 0; } 556 /// 557 pure int isfinite()(real x) { return fpclassify(x) <= 0; } 558 559 //int isinf(real-floating x); 560 /// 561 pure int isinf()(float x) { return fpclassify(x) == FP_INFINITE; } 562 /// 563 pure int isinf()(double x) { return fpclassify(x) == FP_INFINITE; } 564 /// 565 pure int isinf()(real x) { return fpclassify(x) == FP_INFINITE; } 566 567 //int isnan(real-floating x); 568 version (none) // requires MSVCRT 12+ (VS 2013) 569 { 570 /// 571 pure int isnan(float x) { return fpclassify(x) == FP_NAN; } 572 /// 573 pure int isnan(double x) { return fpclassify(x) == FP_NAN; } 574 /// 575 pure int isnan(real x) { return fpclassify(x) == FP_NAN; } 576 } 577 else // for backward compatibility with older runtimes 578 { 579 /// 580 pure int isnan(float x) { version (Win64) return _isnanf(x); else return _isnan(cast(double) x); } 581 /// 582 extern(C) pragma(mangle, "_isnan") pure int isnan(double x); 583 /// 584 pure int isnan(real x) { return _isnan(cast(double) x); } 585 } 586 587 //int isnormal(real-floating x); 588 /// 589 pure int isnormal()(float x) { return fpclassify(x) == FP_NORMAL; } 590 /// 591 pure int isnormal()(double x) { return fpclassify(x) == FP_NORMAL; } 592 /// 593 pure int isnormal()(real x) { return fpclassify(x) == FP_NORMAL; } 594 595 //int signbit(real-floating x); 596 /// 597 extern(C) pragma(mangle, "_fdsign") pure int signbit(float x); 598 /// 599 extern(C) pragma(mangle, "_dsign") pure int signbit(double x); 600 /// 601 pure int signbit()(real x) 602 { 603 static if (real.sizeof == double.sizeof) 604 return signbit(cast(double) x); 605 else 606 return (cast(short*)&(x))[4] & 0x8000; 607 } 608 } 609 } 610 } 611 else version (CRuntime_Glibc) 612 { 613 enum 614 { 615 /// 616 FP_NAN, 617 /// 618 FP_INFINITE, 619 /// 620 FP_ZERO, 621 /// 622 FP_SUBNORMAL, 623 /// 624 FP_NORMAL, 625 } 626 627 enum 628 { 629 /// 630 FP_FAST_FMA = 0, 631 /// 632 FP_FAST_FMAF = 0, 633 /// 634 FP_FAST_FMAL = 0, 635 } 636 637 pure int __fpclassifyf(float x); 638 pure int __fpclassify(double x); 639 pure int __fpclassifyl(real x); 640 641 pure int __finitef(float x); 642 pure int __finite(double x); 643 pure int __finitel(real x); 644 645 pure int __isinff(float x); 646 pure int __isinf(double x); 647 pure int __isinfl(real x); 648 649 pure int __isnanf(float x); 650 pure int __isnan(double x); 651 pure int __isnanl(real x); 652 653 pure int __signbitf(float x); 654 pure int __signbit(double x); 655 pure int __signbitl(real x); 656 657 //int fpclassify(real-floating x); 658 /// 659 pragma(mangle, "__fpclassifyf") pure int fpclassify(float x); 660 /// 661 pragma(mangle, "__fpclassify") pure int fpclassify(double x); 662 /// 663 pragma(mangle, real.sizeof == double.sizeof ? "__fpclassify" : "__fpclassifyl") 664 pure int fpclassify(real x); 665 666 //int isfinite(real-floating x); 667 /// 668 pragma(mangle, "__finitef") pure int isfinite(float x); 669 /// 670 pragma(mangle, "__finite") pure int isfinite(double x); 671 /// 672 pragma(mangle, real.sizeof == double.sizeof ? "__finite" : "__finitel") 673 pure int isfinite(real x); 674 675 //int isinf(real-floating x); 676 /// 677 pragma(mangle, "__isinff") pure int isinf(float x); 678 /// 679 pragma(mangle, "__isinf") pure int isinf(double x); 680 /// 681 pragma(mangle, real.sizeof == double.sizeof ? "__isinf" : "__isinfl") 682 pure int isinf(real x); 683 684 //int isnan(real-floating x); 685 /// 686 pragma(mangle, "__isnanf") pure int isnan(float x); 687 /// 688 pragma(mangle, "__isnan") pure int isnan(double x); 689 /// 690 pragma(mangle, real.sizeof == double.sizeof ? "__isnan" : "__isnanl") 691 pure int isnan(real x); 692 693 //int isnormal(real-floating x); 694 /// 695 extern (D) pure int isnormal(float x) { return fpclassify(x) == FP_NORMAL; } 696 /// 697 extern (D) pure int isnormal(double x) { return fpclassify(x) == FP_NORMAL; } 698 /// 699 extern (D) pure int isnormal(real x) { return fpclassify(x) == FP_NORMAL; } 700 701 //int signbit(real-floating x); 702 /// 703 pragma(mangle, "__signbitf") pure int signbit(float x); 704 /// 705 pragma(mangle, "__signbit") pure int signbit(double x); 706 /// 707 pragma(mangle, real.sizeof == double.sizeof ? "__signbit" : "__signbitl") 708 pure int signbit(real x); 709 } 710 else version (CRuntime_Musl) 711 { 712 enum 713 { 714 /// 715 FP_NAN, 716 /// 717 FP_INFINITE, 718 /// 719 FP_ZERO, 720 /// 721 FP_SUBNORMAL, 722 /// 723 FP_NORMAL, 724 } 725 726 enum 727 { 728 /// 729 FP_FAST_FMA = 0, 730 /// 731 FP_FAST_FMAF = 0, 732 /// 733 FP_FAST_FMAL = 0, 734 } 735 736 pure { 737 int __fpclassifyf(float x); 738 int __fpclassify(double x); 739 int __fpclassifyl(real x); 740 741 int __signbitf(float x); 742 int __signbit(double x); 743 int __signbitl(real x); 744 } 745 746 //int fpclassify(real-floating x); 747 /// 748 pragma(mangle, "__fpclassifyf") pure int fpclassify(float x); 749 /// 750 pragma(mangle, "__fpclassify") pure int fpclassify(double x); 751 /// 752 pragma(mangle, real.sizeof == double.sizeof ? "__fpclassify" : "__fpclassifyl") 753 pure int fpclassify(real x); 754 extern (D) pure 755 { 756 private uint __FLOAT_BITS(float __f) 757 { 758 union __u_t { 759 float __f; 760 uint __i; 761 } 762 __u_t __u; 763 __u.__f = __f; 764 return __u.__i; 765 } 766 private ulong __DOUBLE_BITS(double __f) 767 { 768 union __u_t { 769 double __f; 770 ulong __i; 771 } 772 __u_t __u; 773 __u.__f = __f; 774 return __u.__i; 775 } 776 777 //int isfinite(real-floating x); 778 /// 779 int isfinite(float x) { return (__FLOAT_BITS(x) & 0x7fffffff) < 0x7f800000; } 780 /// 781 int isfinite(double x) { return (__DOUBLE_BITS(x) & -1UL>>1) < 0x7ffUL<<52; } 782 /// 783 int isfinite(real x) 784 { 785 return (real.sizeof == double.sizeof) 786 ? isfinite(cast(double)x) 787 : __fpclassifyl(x) > FP_INFINITE; 788 } 789 790 //int isinf(real-floating x); 791 /// 792 int isinf(float x) { return (__FLOAT_BITS(x) & 0x7fffffff) == 0x7f800000; } 793 /// 794 int isinf(double x) { return (__DOUBLE_BITS(x) & -1UL>>1) == 0x7ffUL<<52; } 795 /// 796 int isinf(real x) 797 { 798 return (real.sizeof == double.sizeof) 799 ? isinf(cast(double)x) 800 : __fpclassifyl(x) == FP_INFINITE; 801 } 802 803 //int isnan(real-floating x); 804 /// 805 int isnan(float x) { return (__FLOAT_BITS(x) & 0x7fffffff) > 0x7f800000; } 806 /// 807 int isnan(double x) { return (__DOUBLE_BITS(x) & -1UL>>1) > 0x7ffUL<<52; } 808 /// 809 int isnan(real x) 810 { 811 return (real.sizeof == double.sizeof) 812 ? isnan(cast(double)x) 813 : __fpclassifyl(x) == FP_NAN; 814 } 815 816 //int isnormal(real-floating x); 817 /// 818 int isnormal(float x) { return fpclassify(x) == FP_NORMAL; } 819 /// 820 int isnormal(double x) { return fpclassify(x) == FP_NORMAL; } 821 /// 822 int isnormal(real x) { return fpclassify(x) == FP_NORMAL; } 823 } 824 825 //int signbit(real-floating x); 826 /// 827 pragma(mangle, "__signbitf") pure int signbit(float x); 828 /// 829 pragma(mangle, "__signbit") pure int signbit(double x); 830 /// 831 pragma(mangle, real.sizeof == double.sizeof ? "__signbit" : "__signbitl") 832 pure int signbit(real x); 833 } 834 else version (CRuntime_UClibc) 835 { 836 enum 837 { 838 /// 839 FP_NAN, 840 /// 841 FP_INFINITE, 842 /// 843 FP_ZERO, 844 /// 845 FP_SUBNORMAL, 846 /// 847 FP_NORMAL, 848 } 849 850 enum 851 { 852 /// 853 FP_FAST_FMA = 0, 854 /// 855 FP_FAST_FMAF = 0, 856 /// 857 FP_FAST_FMAL = 0, 858 } 859 860 pure int __fpclassifyf(float x); 861 pure int __fpclassify(double x); 862 pure int __fpclassifyl(real x); 863 864 pure int __finitef(float x); 865 pure int __finite(double x); 866 pure int __finitel(real x); 867 868 pure int __isinff(float x); 869 pure int __isinf(double x); 870 pure int __isinfl(real x); 871 872 pure int __isnanf(float x); 873 pure int __isnan(double x); 874 pure int __isnanl(real x); 875 876 pure int __signbitf(float x); 877 pure int __signbit(double x); 878 pure int __signbitl(real x); 879 880 /// 881 pragma(mangle, "__fpclassifyf") pure int fpclassify(float x); 882 /// 883 pragma(mangle, "__fpclassify") pure int fpclassify(double x); 884 /// 885 pragma(mangle, real.sizeof == double.sizeof ? "__fpclassify" : "__fpclassifyl") 886 pure int fpclassify(real x); 887 888 /// 889 pragma(mangle, "__finitef") pure int isfinite(float x); 890 /// 891 pragma(mangle, "__finite") pure int isfinite(double x); 892 /// 893 pragma(mangle, real.sizeof == double.sizeof ? "__finite" : "__finitel") 894 pure int isfinite(real x); 895 896 /// 897 pragma(mangle, "__isinff") pure int isinf(float x); 898 /// 899 pragma(mangle, "__isinf") pure int isinf(double x); 900 /// 901 pragma(mangle, real.sizeof == double.sizeof ? "__isinf" : "__isinfl") 902 pure int isinf(real x); 903 904 /// 905 pragma(mangle, "__isnanf") pure int isnan(float x); 906 /// 907 pragma(mangle, "__isnan") pure int isnan(double x); 908 /// 909 pragma(mangle, real.sizeof == double.sizeof ? "__isnan" : "__isnanl") 910 pure int isnan(real x); 911 912 extern (D) pure 913 { 914 /// 915 int isnormal(float x) { return fpclassify(x) == FP_NORMAL; } 916 /// 917 int isnormal(double x) { return fpclassify(x) == FP_NORMAL; } 918 /// 919 int isnormal(real x) { return fpclassify(x) == FP_NORMAL; } 920 } 921 922 /// 923 pragma(mangle, "__signbitf") pure int signbit(float x); 924 /// 925 pragma(mangle, "__signbit") pure int signbit(double x); 926 /// 927 pragma(mangle, real.sizeof == double.sizeof ? "__signbit" : "__signbitl") 928 pure int signbit(real x); 929 } 930 else version (Darwin) 931 { 932 enum 933 { 934 /// 935 FP_NAN = 1, 936 /// 937 FP_INFINITE = 2, 938 /// 939 FP_ZERO = 3, 940 /// 941 FP_NORMAL = 4, 942 /// 943 FP_SUBNORMAL = 5, 944 } 945 946 enum 947 { 948 /// 949 FP_FAST_FMA = 0, 950 /// 951 FP_FAST_FMAF = 0, 952 /// 953 FP_FAST_FMAL = 0, 954 } 955 956 pure int __fpclassifyf(float x); 957 pure int __fpclassifyd(double x); 958 959 pure int __isfinitef(float x); 960 pure int __isfinited(double x); 961 962 pure int __isinff(float x); 963 pure int __isinfd(double x); 964 965 pure int __isnanf(float x); 966 pure int __isnand(double x); 967 968 // __isnormal family exists, but iOS implementation returns wrong results 969 // for subnormals 970 971 pure int __signbitf(float x); 972 pure int __signbitd(double x); 973 pure int __signbitl(real x); 974 975 // Support of OSX < 10.8 needs legacy function names without "l" suffix 976 // with exception of __signbitl. Otherwise could use else version like 977 // other Darwins 978 version (OSX) 979 { 980 version (AArch64) 981 { 982 // Available in macOS ARM 983 pure int __fpclassifyl(real x); 984 pure int __isfinitel(real x); 985 pure int __isinfl(real x); 986 pure int __isnanl(real x); 987 } 988 else 989 { 990 pure int __fpclassify(real x); 991 pure int __isfinite(real x); 992 pure int __isinf(real x); 993 pure int __isnan(real x); 994 alias __fpclassifyl = __fpclassify; 995 alias __isfinitel = __isfinite; 996 alias __isinfl = __isinf; 997 alias __isnanl = __isnan; 998 } 999 } 1000 else 1001 { 1002 // Available OSX >= 10.8, iOS >= 6.0, all TVOS and WatchOS 1003 pure int __fpclassifyl(real x); 1004 pure int __isfinitel(real x); 1005 pure int __isinfl(real x); 1006 pure int __isnanl(real x); 1007 } 1008 1009 //int fpclassify(real-floating x); 1010 /// 1011 pragma(mangle, "__fpclassifyf") pure int fpclassify(float x); 1012 /// 1013 pragma(mangle, "__fpclassifyd") pure int fpclassify(double x); 1014 /// 1015 pragma(mangle, __fpclassifyl.mangleof) pure int fpclassify(real x); 1016 1017 //int isfinite(real-floating x); 1018 /// 1019 pragma(mangle, "__isfinitef") pure int isfinite(float x); 1020 /// 1021 pragma(mangle, "__isfinited") pure int isfinite(double x); 1022 /// 1023 pragma(mangle, __isfinitel.mangleof) pure int isfinite(real x); 1024 1025 //int isinf(real-floating x); 1026 /// 1027 pragma(mangle, "__isinff") pure int isinf(float x); 1028 /// 1029 pragma(mangle, "__isinfd") pure int isinf(double x); 1030 /// 1031 pragma(mangle, __isinfl.mangleof) pure int isinf(real x); 1032 1033 //int isnan(real-floating x); 1034 /// 1035 pragma(mangle, "__isnanf") pure int isnan(float x); 1036 /// 1037 pragma(mangle, "__isnand") pure int isnan(double x); 1038 /// 1039 pragma(mangle, __isnanl.mangleof) pure int isnan(real x); 1040 1041 extern (D) 1042 { 1043 //int isnormal(real-floating x); 1044 /// 1045 pure int isnormal(float x) { return fpclassify(x) == FP_NORMAL; } 1046 /// 1047 pure int isnormal(double x) { return fpclassify(x) == FP_NORMAL; } 1048 /// 1049 pure int isnormal(real x) { return fpclassify(x) == FP_NORMAL; } 1050 } 1051 1052 //int signbit(real-floating x); 1053 /// 1054 pragma(mangle, "__signbitf") pure int signbit(float x); 1055 /// 1056 pragma(mangle, "__signbitd") pure int signbit(double x); 1057 /// 1058 pragma(mangle, "__signbitl") pure int signbit(real x); 1059 } 1060 else version (FreeBSD) 1061 { 1062 enum 1063 { 1064 /// 1065 FP_INFINITE = 0x01, 1066 /// 1067 FP_NAN = 0x02, 1068 /// 1069 FP_NORMAL = 0x04, 1070 /// 1071 FP_SUBNORMAL = 0x08, 1072 /// 1073 FP_ZERO = 0x10, 1074 } 1075 1076 enum 1077 { 1078 /// 1079 FP_FAST_FMA = 0, 1080 /// 1081 FP_FAST_FMAF = 0, 1082 /// 1083 FP_FAST_FMAL = 0, 1084 } 1085 1086 pure int __fpclassifyd(double); 1087 pure int __fpclassifyf(float); 1088 pure int __fpclassifyl(real); 1089 pure int __isfinitef(float); 1090 pure int __isfinite(double); 1091 pure int __isfinitel(real); 1092 pure int __isinff(float); 1093 pure int __isinfl(real); 1094 pure int __isnanl(real); 1095 pure int __isnormalf(float); 1096 pure int __isnormal(double); 1097 pure int __isnormall(real); 1098 pure int __signbit(double); 1099 pure int __signbitf(float); 1100 pure int __signbitl(real); 1101 1102 //int fpclassify(real-floating x); 1103 /// 1104 pragma(mangle, "__fpclassifyf") pure int fpclassify(float x); 1105 /// 1106 pragma(mangle, "__fpclassifyd") pure int fpclassify(double x); 1107 /// 1108 pragma(mangle, "__fpclassifyl") pure int fpclassify(real x); 1109 1110 //int isfinite(real-floating x); 1111 /// 1112 pragma(mangle, "__isfinitef") pure int isfinite(float x); 1113 /// 1114 pragma(mangle, "__isfinite") pure int isfinite(double x); 1115 /// 1116 pragma(mangle, "__isfinitel") pure int isfinite(real x); 1117 1118 //int isinf(real-floating x); 1119 /// 1120 pragma(mangle, "__isinff") pure int isinf(float x); 1121 /// 1122 extern (D) pure int isinf(double x) { return __isinfl(x); } 1123 /// 1124 pragma(mangle, "__isinfl") pure int isinf(real x); 1125 1126 //int isnan(real-floating x); 1127 /// 1128 extern (D) pure int isnan(float x) { return __isnanl(x); } 1129 /// 1130 extern (D) pure int isnan(double x) { return __isnanl(x); } 1131 /// 1132 pragma(mangle, "__isnanl") pure int isnan(real x); 1133 1134 //int isnormal(real-floating x); 1135 /// 1136 pragma(mangle, "__isnormalf") pure int isnormal(float x); 1137 /// 1138 pragma(mangle, "__isnormal") pure int isnormal(double x); 1139 /// 1140 pragma(mangle, "__isnormall") pure int isnormal(real x); 1141 1142 //int signbit(real-floating x); 1143 /// 1144 pragma(mangle, "__signbitf") pure int signbit(float x); 1145 /// 1146 pragma(mangle, "__signbit") pure int signbit(double x); 1147 /// 1148 extern (D) pure int signbit(real x) { return __signbit(x); } 1149 } 1150 else version (OpenBSD) 1151 { 1152 enum 1153 { 1154 /// 1155 FP_INFINITE = 0x01, 1156 /// 1157 FP_NAN = 0x02, 1158 /// 1159 FP_NORMAL = 0x04, 1160 /// 1161 FP_SUBNORMAL = 0x08, 1162 /// 1163 FP_ZERO = 0x10, 1164 } 1165 1166 enum 1167 { 1168 /// 1169 FP_FAST_FMA = 1, 1170 /// 1171 FP_FAST_FMAF = 1, 1172 /// 1173 FP_FAST_FMAL = 1, 1174 } 1175 1176 pure int __fpclassify(double); 1177 pure int __fpclassifyf(float); 1178 pure int __fpclassifyl(real); 1179 pure int __isfinitef(float); 1180 pure int __isfinite(double); 1181 pure int __isfinitel(real); 1182 pure int __isinff(float); 1183 pure int __isinfl(real); 1184 pure int __isnanl(real); 1185 pure int __isnormalf(float); 1186 pure int __isnormal(double); 1187 pure int __isnormall(real); 1188 pure int __signbit(double); 1189 pure int __signbitf(float); 1190 pure int __signbitl(real); 1191 1192 //int fpclassify(real-floating x); 1193 /// 1194 pragma(mangle, "__fpclassifyf") pure int fpclassify(float x); 1195 /// 1196 pragma(mangle, "__fpclassify") pure int fpclassify(double x); 1197 /// 1198 pragma(mangle, "__fpclassifyl") pure int fpclassify(real x); 1199 1200 //int isfinite(real-floating x); 1201 /// 1202 pragma(mangle, "__isfinitef") pure int isfinite(float x); 1203 /// 1204 pragma(mangle, "__isfinite") pure int isfinite(double x); 1205 /// 1206 pragma(mangle, "__isfinitel") pure int isfinite(real x); 1207 1208 //int isinf(real-floating x); 1209 /// 1210 pragma(mangle, "__isinff") pure int isinf(float x); 1211 /// 1212 extern (D) pure int isinf(double x) { return __isinfl(x); } 1213 /// 1214 pragma(mangle, "__isinfl") pure int isinf(real x); 1215 1216 //int isnan(real-floating x); 1217 /// 1218 extern (D) pure int isnan(float x) { return __isnanl(x); } 1219 /// 1220 extern (D) pure int isnan(double x) { return __isnanl(x); } 1221 /// 1222 pragma(mangle, "__isnanl") pure int isnan(real x); 1223 1224 //int isnormal(real-floating x); 1225 /// 1226 pragma(mangle, "__isnormalf") pure int isnormal(float x); 1227 /// 1228 pragma(mangle, "__isnormal") pure int isnormal(double x); 1229 /// 1230 pragma(mangle, "__isnormall") pure int isnormal(real x); 1231 1232 //int signbit(real-floating x); 1233 /// 1234 pragma(mangle, "__signbitf") pure int signbit(float x); 1235 /// 1236 pragma(mangle, "__signbit") pure int signbit(double x); 1237 /// 1238 extern (D) pure int signbit(real x) { return __signbit(x); } 1239 } 1240 else version (NetBSD) 1241 { 1242 enum 1243 { 1244 /// 1245 FP_INFINITE = 0, 1246 /// 1247 FP_NAN = 1, 1248 /// 1249 FP_NORMAL = 2, 1250 /// 1251 FP_SUBNORMAL = 3, 1252 /// 1253 FP_ZERO = 4, 1254 } 1255 1256 enum 1257 { 1258 /// 1259 FP_FAST_FMA = 0, 1260 /// 1261 FP_FAST_FMAF = 0, 1262 /// 1263 FP_FAST_FMAL = 0, 1264 } 1265 1266 pure uint __fpclassifyf(float x); 1267 pure uint __fpclassifyd(double x); 1268 pure uint __fpclassifyl(real x); 1269 1270 //int fpclassify(real-floating x); 1271 /// 1272 pragma(mangle, "__fpclassifyf") pure int fpclassify(float x); 1273 /// 1274 pragma(mangle, "__fpclassifyd") pure int fpclassify(double x); 1275 /// 1276 pragma(mangle, real.sizeof == double.sizeof ? "__fpclassifyd" : "__fpclassifyl") 1277 pure int fpclassify(real x); 1278 1279 extern (D) 1280 { 1281 //int isfinite(real-floating x); 1282 /// 1283 pure int isfinite(float x) { return fpclassify(x) >= FP_NORMAL; } 1284 /// 1285 pure int isfinite(double x) { return fpclassify(x) >= FP_NORMAL; } 1286 /// 1287 pure int isfinite(real x) { return fpclassify(x) >= FP_NORMAL; } 1288 1289 //int isinf(real-floating x); 1290 /// 1291 pure int isinf(float x) { return fpclassify(x) == FP_INFINITE; } 1292 /// 1293 pure int isinf(double x) { return fpclassify(x) == FP_INFINITE; } 1294 /// 1295 pure int isinf(real x) { return fpclassify(x) == FP_INFINITE; } 1296 1297 //int isnan(real-floating x); 1298 /// 1299 pure int isnan(float x) { return fpclassify(x) == FP_NAN; } 1300 /// 1301 pure int isnan(double x) { return fpclassify(x) == FP_NAN; } 1302 /// 1303 pure int isnan(real x) { return fpclassify(x) == FP_NAN; } 1304 1305 //int isnormal(real-floating x); 1306 /// 1307 pure int isnormal(float x) { return fpclassify(x) == FP_NORMAL; } 1308 /// 1309 pure int isnormal(double x) { return fpclassify(x) == FP_NORMAL; } 1310 /// 1311 pure int isnormal(real x) { return fpclassify(x) == FP_NORMAL; } 1312 1313 //int signbit(real-floating x); 1314 /// 1315 pure int signbit(float x) { return (cast(short*)&(x))[1] & 0x8000; } 1316 /// 1317 pure int signbit(double x) { return (cast(short*)&(x))[3] & 0x8000; } 1318 /// 1319 pure int signbit(real x) 1320 { 1321 return (real.sizeof == double.sizeof) 1322 ? (cast(short*)&(x))[3] & 0x8000 1323 : (cast(short*)&(x))[4] & 0x8000; 1324 } 1325 } 1326 } 1327 else version (DragonFlyBSD) 1328 { 1329 enum 1330 { 1331 FP_INFINITE = 0x01, 1332 FP_NAN = 0x02, 1333 FP_NORMAL = 0x04, 1334 FP_SUBNORMAL = 0x08, 1335 FP_ZERO = 0x10, 1336 } 1337 1338 /* 1339 * /usr/include/math.h : martynas@openbsd believes only F version is true. 1340 enum FP_FAST_FMA = 1; 1341 enum FP_FAST_FMAL = 1; 1342 */ 1343 enum FP_FAST_FMAF = 1; 1344 1345 pure int __fpclassifyd(double); 1346 pure int __fpclassifyf(float); 1347 pure int __fpclassifyl(real); 1348 pure int __isfinitef(float); 1349 pure int __isfinite(double); 1350 pure int __isfinitel(real); 1351 pure int __isinff(float); 1352 pure int __isinf(double); 1353 pure int __isinfl(real); 1354 pure int __isnanf(float); 1355 pure int __isnan(double); 1356 pure int __isnanl(real); 1357 pure int __isnormalf(float); 1358 pure int __isnormal(double); 1359 pure int __isnormall(real); 1360 pure int __signbit(double); 1361 pure int __signbitf(float); 1362 pure int __signbitl(real); 1363 1364 pragma(mangle, "__fpclassifyf") pure int fpclassify(float x); 1365 pragma(mangle, "__fpclassifyd") pure int fpclassify(double x); 1366 pragma(mangle, "__fpclassifyl") pure int fpclassify(real x); 1367 1368 pragma(mangle, "__isfinitef") pure int isfinite(float x); 1369 pragma(mangle, "__isfinite") pure int isfinite(double x); 1370 pragma(mangle, "__isfinitel") pure int isfinite(real x); 1371 1372 pragma(mangle, "__isinff") pure int isinf(float x); 1373 pragma(mangle, "__isinf") pure int isinf(double x); 1374 pragma(mangle, "__isinfl") pure int isinf(real x); 1375 1376 pragma(mangle, "__isnanf") pure int isnan(float x); 1377 pragma(mangle, "__isnan") pure int isnan(double x); 1378 pragma(mangle, "__isnanl") pure int isnan(real x); 1379 1380 pragma(mangle, "__isnormalf") pure int isnormal(float x); 1381 pragma(mangle, "__isnormal") pure int isnormal(double x); 1382 pragma(mangle, "__isnormall") pure int isnormal(real x); 1383 1384 pragma(mangle, "__signbitf") pure int signbit(float x); 1385 pragma(mangle, "__signbit") pure int signbit(double x); 1386 pragma(mangle, "__signbitl") pure int signbit(real x); 1387 } 1388 else version (Solaris) 1389 { 1390 enum 1391 { 1392 FP_INFINITE = 3, 1393 FP_NAN = 4, 1394 FP_NORMAL = 2, 1395 FP_SUBNORMAL = 1, 1396 FP_ZERO = 0, 1397 } 1398 1399 enum 1400 { 1401 /// 1402 FP_FAST_FMA = 0, 1403 /// 1404 FP_FAST_FMAF = 0, 1405 /// 1406 FP_FAST_FMAL = 0, 1407 } 1408 1409 extern (D) 1410 { 1411 //int fpclassify(real-floating x); 1412 /// 1413 pure int fpclassify(float x) 1414 { 1415 return isnan(x) ? FP_NAN : isinf(x) ? FP_INFINITE : 1416 isnormal(x) ? FP_NORMAL : x == 0.0f ? FP_ZERO : 1417 FP_SUBNORMAL; 1418 } 1419 1420 /// 1421 pure int fpclassify(double x) 1422 { 1423 return isnan(x) ? FP_NAN : isinf(x) ? FP_INFINITE : 1424 isnormal(x) ? FP_NORMAL : x == 0.0 ? FP_ZERO : 1425 FP_SUBNORMAL; 1426 } 1427 1428 /// 1429 pure int fpclassify(real x) 1430 { 1431 return isnan(x) ? FP_NAN : isinf(x) ? FP_INFINITE : 1432 isnormal(x) ? FP_NORMAL : x == 0.0L ? FP_ZERO : 1433 FP_SUBNORMAL; 1434 } 1435 1436 //int isfinite(real-floating x); 1437 /// 1438 pure int isfinite(float x) { return !isnan(x) && !isinf(x); } 1439 /// 1440 pure int isfinite(double x) { return !isnan(x) && !isinf(x); } 1441 /// 1442 pure int isfinite(real x) { return !isnan(x) && !isinf(x); } 1443 1444 //int isinf(real-floating x); 1445 /// 1446 pure int isinf(float x) { return x == float.infinity || x == -float.infinity; } 1447 /// 1448 pure int isinf(double x) { return x == double.infinity || x == -double.infinity; } 1449 /// 1450 pure int isinf(real x) { return x == real.infinity || x == -real.infinity; } 1451 1452 //int isnan(real-floating x); 1453 /// 1454 pure int isnan(float x) { return x != x; } 1455 /// 1456 pure int isnan(double x) { return x != x; } 1457 /// 1458 pure int isnan(real x) { return x != x; } 1459 1460 //int isnormal(real-floating x); 1461 /// 1462 pure int isnormal(float x) 1463 { 1464 import core.math; 1465 return isfinite(x) && fabs(x) >= float.min_normal; 1466 } 1467 /// 1468 pure int isnormal(double x) 1469 { 1470 import core.math; 1471 return isfinite(x) && fabs(x) >= double.min_normal; 1472 } 1473 /// 1474 pure int isnormal(real x) 1475 { 1476 import core.math; 1477 return isfinite(x) && fabs(x) >= real.min_normal; 1478 } 1479 1480 //int signbit(real-floating x); 1481 /// 1482 pure int signbit(float x) 1483 { 1484 version (SPARC_Any) 1485 return cast(int)(*cast(uint*)&x >> 31); 1486 else version (X86_Any) 1487 return cast(int)(*cast(uint*)&x >> 31); 1488 else 1489 static assert(false, "Architecture not supported."); 1490 } 1491 /// 1492 pure int signbit(double x) 1493 { 1494 version (SPARC_Any) 1495 return cast(int)(*cast(uint*)&x >> 31); 1496 else version (X86_Any) 1497 return cast(int)((cast(uint*)&x)[1] >> 31); 1498 else 1499 static assert(false, "Architecture not supported."); 1500 } 1501 /// 1502 pure int signbit(real x) 1503 { 1504 version (SPARC_Any) 1505 return cast(int)(*cast(uint*)&x >> 31); 1506 else version (X86_Any) 1507 return cast(int)((cast(ushort *)&x)[4] >> 15); 1508 else 1509 static assert(false, "Architecture not supported."); 1510 } 1511 } 1512 } 1513 else version (CRuntime_Bionic) 1514 { 1515 enum 1516 { 1517 /// 1518 FP_INFINITE = 0x01, 1519 /// 1520 FP_NAN = 0x02, 1521 /// 1522 FP_NORMAL = 0x04, 1523 /// 1524 FP_SUBNORMAL = 0x08, 1525 /// 1526 FP_ZERO = 0x10, 1527 } 1528 1529 /// 1530 enum FP_FAST_FMAF; 1531 1532 pure int __fpclassifyd(double); 1533 pure int __fpclassifyf(float); 1534 pure int __fpclassifyl(real); 1535 1536 pure int __isfinitef(float); 1537 pure int __isfinite(double); 1538 pure int __isfinitel(real); 1539 1540 pure int __isinff(float); 1541 pure int __isinf(double); 1542 pure int __isinfl(real); 1543 1544 pure int isnanf(float); 1545 pure int isnan(double); 1546 pure int __isnanl(real); 1547 1548 pure int __isnormalf(float); 1549 pure int __isnormal(double); 1550 pure int __isnormall(real); 1551 1552 pure int __signbit(double); 1553 pure int __signbitf(float); 1554 pure int __signbitl(real); 1555 1556 //int fpclassify(real-floating x); 1557 /// 1558 pragma(mangle, "__fpclassifyf") pure int fpclassify(float x); 1559 /// 1560 pragma(mangle, "__fpclassifyd") pure int fpclassify(double x); 1561 /// 1562 pragma(mangle, "__fpclassifyl") pure int fpclassify(real x); 1563 1564 //int isfinite(real-floating x); 1565 /// 1566 pragma(mangle, "__isfinitef") pure int isfinite(float x); 1567 /// 1568 pragma(mangle, "__isfinite") pure int isfinite(double x); 1569 /// 1570 pragma(mangle, "__isfinitel") pure int isfinite(real x); 1571 1572 //int isinf(real-floating x); 1573 /// 1574 pragma(mangle, "__isinff") pure int isinf(float x); 1575 /// 1576 pragma(mangle, "__isinf") pure int isinf(double x); 1577 /// 1578 pragma(mangle, "__isinfl") pure int isinf(real x); 1579 1580 //int isnan(real-floating x); 1581 /// 1582 pragma(mangle, "isnanf") pure int isnan(float x); 1583 /// 1584 pragma(mangle, "__isnanl") pure int isnan(real x); 1585 1586 //int isnormal(real-floating x); 1587 /// 1588 pragma(mangle, "__isnormalf") pure int isnormal(float x); 1589 /// 1590 pragma(mangle, "__isnormal") pure int isnormal(double x); 1591 /// 1592 pragma(mangle, "__isnormall") pure int isnormal(real x); 1593 1594 //int signbit(real-floating x); 1595 /// 1596 pragma(mangle, "__signbitf") pure int signbit(float x); 1597 /// 1598 pragma(mangle, "__signbit") pure int signbit(double x); 1599 /// 1600 pragma(mangle, "__signbitl") pure int signbit(real x); 1601 } 1602 else version (FreeStanding) 1603 { 1604 bool isnan(T)(T f) { assert(0); } 1605 } 1606 1607 extern (D) 1608 { 1609 //int isgreater(real-floating x, real-floating y); 1610 /// 1611 pure int isgreater(float x, float y) { return x > y; } 1612 /// 1613 pure int isgreater(double x, double y) { return x > y; } 1614 /// 1615 pure int isgreater(real x, real y) { return x > y; } 1616 1617 //int isgreaterequal(real-floating x, real-floating y); 1618 /// 1619 pure int isgreaterequal(float x, float y) { return x >= y; } 1620 /// 1621 pure int isgreaterequal(double x, double y) { return x >= y; } 1622 /// 1623 pure int isgreaterequal(real x, real y) { return x >= y; } 1624 1625 //int isless(real-floating x, real-floating y); 1626 /// 1627 pure int isless(float x, float y) { return x < y; } 1628 /// 1629 pure int isless(double x, double y) { return x < y; } 1630 /// 1631 pure int isless(real x, real y) { return x < y; } 1632 1633 //int islessequal(real-floating x, real-floating y); 1634 /// 1635 pure int islessequal(float x, float y) { return x <= y; } 1636 /// 1637 pure int islessequal(double x, double y) { return x <= y; } 1638 /// 1639 pure int islessequal(real x, real y) { return x <= y; } 1640 1641 //int islessgreater(real-floating x, real-floating y); 1642 /// 1643 pure int islessgreater(float x, float y) { return x != y && !isunordered(x, y); } 1644 /// 1645 pure int islessgreater(double x, double y) { return x != y && !isunordered(x, y); } 1646 /// 1647 pure int islessgreater(real x, real y) { return x != y && !isunordered(x, y); } 1648 1649 //int isunordered(real-floating x, real-floating y); 1650 /// 1651 pure int isunordered(float x, float y) { return isnan(x) || isnan(y); } 1652 /// 1653 pure int isunordered(double x, double y) { return isnan(x) || isnan(y); } 1654 /// 1655 pure int isunordered(real x, real y) { return isnan(x) || isnan(y); } 1656 } 1657 1658 /* MS define some functions inline. 1659 * Additionally, their *l functions work with a 64-bit long double and are thus 1660 * useless for 80-bit D reals. So we use our own wrapper implementations working 1661 * internally with reduced 64-bit precision. 1662 * This also enables relaxing real to 64-bit double. 1663 */ 1664 version (CRuntime_Microsoft) // fully supported since MSVCRT 12 (VS 2013) only 1665 { 1666 /// 1667 double acos(double x); 1668 /// 1669 float acosf(float x); 1670 /// 1671 extern(D) real acosl()(real x) { return acos(cast(double) x); } 1672 1673 /// 1674 double asin(double x); 1675 /// 1676 float asinf(float x); 1677 /// 1678 extern(D) real asinl()(real x) { return asin(cast(double) x); } 1679 1680 /// 1681 pure double atan(double x); 1682 /// 1683 pure float atanf(float x); 1684 /// 1685 pure extern(D) real atanl()(real x) { return atan(cast(double) x); } 1686 1687 /// 1688 double atan2(double y, double x); 1689 /// 1690 float atan2f(float y, float x); 1691 /// 1692 extern(D) real atan2l()(real y, real x) { return atan2(cast(double) y, cast(double) x); } 1693 1694 /// 1695 pure double cos(double x); 1696 /// 1697 pure float cosf(float x); 1698 /// 1699 extern(D) pure real cosl()(real x) { return cos(cast(double) x); } 1700 1701 /// 1702 pure double sin(double x); 1703 /// 1704 pure float sinf(float x); 1705 /// 1706 extern(D) pure real sinl()(real x) { return sin(cast(double) x); } 1707 1708 /// 1709 pure double tan(double x); 1710 /// 1711 pure float tanf(float x); 1712 /// 1713 extern(D) pure real tanl()(real x) { return tan(cast(double) x); } 1714 1715 /// 1716 double acosh(double x); 1717 /// 1718 float acoshf(float x); 1719 /// 1720 extern(D) real acoshl()(real x) { return acosh(cast(double) x); } 1721 1722 /// 1723 pure double asinh(double x); 1724 /// 1725 pure float asinhf(float x); 1726 /// 1727 pure extern(D) real asinhl()(real x) { return asinh(cast(double) x); } 1728 1729 /// 1730 double atanh(double x); 1731 /// 1732 float atanhf(float x); 1733 /// 1734 extern(D) real atanhl()(real x) { return atanh(cast(double) x); } 1735 1736 /// 1737 double cosh(double x); 1738 /// 1739 float coshf(float x); 1740 /// 1741 extern(D) real coshl()(real x) { return cosh(cast(double) x); } 1742 1743 /// 1744 double sinh(double x); 1745 /// 1746 float sinhf(float x); 1747 /// 1748 extern(D) real sinhl()(real x) { return sinh(cast(double) x); } 1749 1750 /// 1751 pure double tanh(double x); 1752 /// 1753 pure float tanhf(float x); 1754 /// 1755 extern(D) pure real tanhl()(real x) { return tanh(cast(double) x); } 1756 1757 /// 1758 double exp(double x); 1759 /// 1760 float expf(float x); 1761 /// 1762 extern(D) real expl()(real x) { return exp(cast(double) x); } 1763 1764 /// 1765 double exp2(double x); 1766 /// 1767 float exp2f(float x); 1768 /// 1769 extern(D) real exp2l()(real x) { return exp2(cast(double) x); } 1770 1771 /// 1772 double expm1(double x); 1773 /// 1774 float expm1f(float x); 1775 /// 1776 extern(D) real expm1l()(real x) { return expm1(cast(double) x); } 1777 1778 /// 1779 pure double frexp(double value, int* exp); 1780 /// 1781 extern(D) pure float frexpf()(float value, int* exp) { return cast(float) frexp(value, exp); } 1782 /// 1783 extern(D) pure real frexpl()(real value, int* exp) { return frexp(cast(double) value, exp); } 1784 1785 /// 1786 int ilogb(double x); 1787 /// 1788 int ilogbf(float x); 1789 /// 1790 extern(D) int ilogbl()(real x) { return ilogb(cast(double) x); } 1791 1792 /// 1793 double ldexp(double x, int exp); 1794 /// 1795 extern(D) float ldexpf()(float x, int exp) { return cast(float) ldexp(x, exp); } 1796 /// 1797 extern(D) real ldexpl()(real x, int exp) { return ldexp(cast(double) x, exp); } 1798 1799 /// 1800 double log(double x); 1801 /// 1802 float logf(float x); 1803 /// 1804 extern(D) real logl()(real x) { return log(cast(double) x); } 1805 1806 /// 1807 double log10(double x); 1808 /// 1809 float log10f(float x); 1810 /// 1811 extern(D) real log10l()(real x) { return log10(cast(double) x); } 1812 1813 /// 1814 double log1p(double x); 1815 /// 1816 float log1pf(float x); 1817 /// 1818 extern(D) real log1pl()(real x) { return log1p(cast(double) x); } 1819 1820 /// 1821 double log2(double x); 1822 /// 1823 float log2f(float x); 1824 /// 1825 extern(D) real log2l()(real x) { return log2(cast(double) x); } 1826 1827 /// 1828 double logb(double x); 1829 /// 1830 float logbf(float x); 1831 /// 1832 extern(D) real logbl()(real x) { return logb(cast(double) x); } 1833 1834 /// 1835 pure double modf(double value, double* iptr); 1836 /// 1837 pure float modff(float value, float* iptr); 1838 /// 1839 extern(D) pure real modfl()(real value, real* iptr) 1840 { 1841 double i; 1842 double r = modf(cast(double) value, &i); 1843 *iptr = i; 1844 return r; 1845 } 1846 1847 /// 1848 double scalbn(double x, int n); 1849 /// 1850 float scalbnf(float x, int n); 1851 /// 1852 extern(D) real scalbnl()(real x, int n) { return scalbn(cast(double) x, n); } 1853 1854 /// 1855 double scalbln(double x, c_long n); 1856 /// 1857 float scalblnf(float x, c_long n); 1858 /// 1859 extern(D) real scalblnl()(real x, c_long n) { return scalbln(cast(double) x, n); } 1860 1861 /// 1862 pure double cbrt(double x); 1863 /// 1864 pure float cbrtf(float x); 1865 /// 1866 extern(D) pure real cbrtl()(real x) { return cbrt(cast(double) x); } 1867 1868 /// 1869 pure double fabs(double x); 1870 /// 1871 extern(D) pure float fabsf()(float x) { return cast(float) fabs(x); } 1872 /// 1873 extern(D) pure real fabsl()(real x) { return fabs(cast(double) x); } 1874 1875 /// 1876 extern(C) pragma(mangle, "_hypot") double hypot(double x, double y); 1877 /// 1878 extern(C) pragma(mangle, "_hypotf") float hypotf(float x, float y); 1879 /// 1880 extern(D) real hypotl(real x, real y) { return hypot(cast(double) x, cast(double) y); } 1881 1882 /// 1883 double pow(double x, double y); 1884 /// 1885 float powf(float x, float y); 1886 /// 1887 extern(D) real powl()(real x, real y) { return pow(cast(double) x, cast(double) y); } 1888 1889 /// 1890 double sqrt(double x); 1891 /// 1892 float sqrtf(float x); 1893 /// 1894 extern(D) real sqrtl()(real x) { return sqrt(cast(double) x); } 1895 1896 /// 1897 pure double erf(double x); 1898 /// 1899 pure float erff(float x); 1900 /// 1901 extern(D) pure real erfl()(real x) { return erf(cast(double) x); } 1902 1903 /// 1904 double erfc(double x); 1905 /// 1906 float erfcf(float x); 1907 /// 1908 extern(D) real erfcl()(real x) { return erfc(cast(double) x); } 1909 1910 /// 1911 double lgamma(double x); 1912 /// 1913 float lgammaf(float x); 1914 /// 1915 extern(D) real lgammal()(real x) { return lgamma(cast(double) x); } 1916 1917 /// 1918 double tgamma(double x); 1919 /// 1920 float tgammaf(float x); 1921 /// 1922 extern(D) real tgammal()(real x) { return tgamma(cast(double) x); } 1923 1924 /// 1925 pure double ceil(double x); 1926 /// 1927 pure float ceilf(float x); 1928 /// 1929 extern(D) pure real ceill()(real x) { return ceil(cast(double) x); } 1930 1931 /// 1932 pure double floor(double x); 1933 /// 1934 pure float floorf(float x); 1935 /// 1936 extern(D) pure real floorl()(real x) { return floor(cast(double) x); } 1937 1938 /// 1939 pure double nearbyint(double x); 1940 /// 1941 pure float nearbyintf(float x); 1942 /// 1943 extern(D) pure real nearbyintl()(real x) { return nearbyint(cast(double) x); } 1944 1945 /// 1946 pure double rint(double x); 1947 /// 1948 pure float rintf(float x); 1949 /// 1950 extern(D) pure real rintl()(real x) { return rint(cast(double) x); } 1951 1952 /// 1953 c_long lrint(double x); 1954 /// 1955 c_long lrintf(float x); 1956 /// 1957 extern(D) c_long lrintl()(real x) { return lrint(cast(double) x); } 1958 1959 /// 1960 long llrint(double x); 1961 /// 1962 long llrintf(float x); 1963 /// 1964 extern(D) long llrintl()(real x) { return llrint(cast(double) x); } 1965 1966 /// 1967 pure double round(double x); 1968 /// 1969 pure float roundf(float x); 1970 /// 1971 extern(D) pure real roundl()(real x) { return round(cast(double) x); } 1972 1973 /// 1974 c_long lround(double x); 1975 /// 1976 c_long lroundf(float x); 1977 /// 1978 extern(D) c_long lroundl()(real x) { return lround(cast(double) x); } 1979 1980 /// 1981 long llround(double x); 1982 /// 1983 long llroundf(float x); 1984 /// 1985 extern(D) long llroundl()(real x) { return llround(cast(double) x); } 1986 1987 /// 1988 pure double trunc(double x); 1989 /// 1990 pure float truncf(float x); 1991 /// 1992 extern(D) pure real truncl()(real x) { return trunc(cast(double) x); } 1993 1994 /// 1995 double fmod(double x, double y); 1996 /// 1997 float fmodf(float x, float y); 1998 /// 1999 extern(D) real fmodl()(real x, real y) { return fmod(cast(double) x, cast(double) y); } 2000 2001 /// 2002 double remainder(double x, double y); 2003 /// 2004 float remainderf(float x, float y); 2005 /// 2006 extern(D) real remainderl()(real x, real y) { return remainder(cast(double) x, cast(double) y); } 2007 2008 /// 2009 double remquo(double x, double y, int* quo); 2010 /// 2011 float remquof(float x, float y, int* quo); 2012 /// 2013 extern(D) real remquol()(real x, real y, int* quo) { return remquo(cast(double) x, cast(double) y, quo); } 2014 2015 /// 2016 pure double copysign(double x, double y); 2017 /// 2018 pure float copysignf(float x, float y); 2019 /// 2020 extern(D) pure real copysignl()(real x, real y) { return copysign(cast(double) x, cast(double) y); } 2021 2022 /// 2023 pure double nan(char* tagp); 2024 /// 2025 pure float nanf(char* tagp); 2026 /// 2027 extern(D) pure real nanl()(char* tagp) { return nan(tagp); } 2028 2029 /// 2030 double nextafter(double x, double y); 2031 /// 2032 float nextafterf(float x, float y); 2033 /// 2034 extern(D) real nextafterl()(real x, real y) { return nextafter(cast(double) x, cast(double) y); } 2035 2036 /// 2037 double nexttoward(double x, real y); 2038 /// 2039 float nexttowardf(float x, real y); 2040 /// 2041 extern(D) real nexttowardl()(real x, real y) { return nexttoward(cast(double) x, cast(double) y); } 2042 2043 /// 2044 double fdim(double x, double y); 2045 /// 2046 float fdimf(float x, float y); 2047 /// 2048 extern(D) real fdiml()(real x, real y) { return fdim(cast(double) x, cast(double) y); } 2049 2050 /// 2051 pure double fmax(double x, double y); 2052 /// 2053 pure float fmaxf(float x, float y); 2054 /// 2055 extern(D) pure real fmaxl()(real x, real y) { return fmax(cast(double) x, cast(double) y); } 2056 2057 /// 2058 pure double fmin(double x, double y); 2059 /// 2060 pure float fminf(float x, float y); 2061 /// 2062 extern(D) pure real fminl()(real x, real y) { return fmin(cast(double) x, cast(double) y); } 2063 2064 /// 2065 pure double fma(double x, double y, double z); 2066 /// 2067 pure float fmaf(float x, float y, float z); 2068 /// 2069 extern(D) pure real fmal()(real x, real y, real z) { return fma(cast(double) x, cast(double) y, cast(double) z); } 2070 } 2071 else version (FreeBSD) 2072 { 2073 /// 2074 double acos(double x); 2075 /// 2076 float acosf(float x); 2077 /// 2078 real acosl(real x); // since 8.0 2079 2080 /// 2081 double asin(double x); 2082 /// 2083 float asinf(float x); 2084 /// 2085 real asinl(real x); // since 8.0 2086 2087 /// 2088 pure double atan(double x); 2089 /// 2090 pure float atanf(float x); 2091 /// 2092 pure real atanl(real x); // since 8.0 2093 2094 /// 2095 double atan2(double y, double x); 2096 /// 2097 float atan2f(float y, float x); 2098 /// 2099 real atan2l(real y, real x); // since 8.0 2100 2101 /// 2102 pure double cos(double x); 2103 /// 2104 pure float cosf(float x); 2105 /// 2106 pure real cosl(real x); // since 8.0 2107 2108 /// 2109 pure double sin(double x); 2110 /// 2111 pure float sinf(float x); 2112 /// 2113 pure real sinl(real x); // since 8.0 2114 2115 /// 2116 pure double tan(double x); 2117 /// 2118 pure float tanf(float x); 2119 /// 2120 pure real tanl(real x); // since 8.0 2121 2122 /// 2123 double acosh(double x); 2124 /// 2125 float acoshf(float x); 2126 /// 2127 real acoshl(real x); // since 10.0 2128 2129 /// 2130 pure double asinh(double x); 2131 /// 2132 pure float asinhf(float x); 2133 /// 2134 pure real asinhl(real x); // since 10.0 2135 2136 /// 2137 double atanh(double x); 2138 /// 2139 float atanhf(float x); 2140 /// 2141 real atanhl(real x); // since 10.0 2142 2143 /// 2144 double cosh(double x); 2145 /// 2146 float coshf(float x); 2147 /// 2148 real coshl(real x); // since 10.1 2149 2150 /// 2151 double sinh(double x); 2152 /// 2153 float sinhf(float x); 2154 /// 2155 real sinhl(real x); // since 10.1 2156 2157 /// 2158 pure double tanh(double x); 2159 /// 2160 pure float tanhf(float x); 2161 /// 2162 pure real tanhl(real x); // since 10.1 2163 2164 /// 2165 double exp(double x); 2166 /// 2167 float expf(float x); 2168 /// 2169 real expl(real x); // since 10.0 2170 2171 /// 2172 double exp2(double x); 2173 /// 2174 float exp2f(float x); 2175 /// 2176 real exp2l(real x); // since 8.0 2177 2178 /// 2179 double expm1(double x); 2180 /// 2181 float expm1f(float x); 2182 /// 2183 real expm1l(real x); // since 10.0 2184 2185 /// 2186 pure double frexp(double value, int* exp); 2187 /// 2188 pure float frexpf(float value, int* exp); 2189 /// 2190 pure real frexpl(real value, int* exp); // since 6.0 2191 2192 /// 2193 int ilogb(double x); 2194 /// 2195 int ilogbf(float x); 2196 /// 2197 int ilogbl(real x); // since 5.4 2198 2199 /// 2200 double ldexp(double x, int exp); 2201 /// 2202 float ldexpf(float x, int exp); 2203 /// 2204 real ldexpl(real x, int exp); // since 6.0 2205 2206 /// 2207 double log(double x); 2208 /// 2209 float logf(float x); 2210 /// 2211 real logl(real x); // since 10.0 2212 2213 /// 2214 double log10(double x); 2215 /// 2216 float log10f(float x); 2217 /// 2218 real log10l(real x); // since 10.0 2219 2220 /// 2221 double log1p(double x); 2222 /// 2223 float log1pf(float x); 2224 /// 2225 real log1pl(real x); // since 10.0 2226 2227 /// 2228 double log2(double x); // since 8.3 2229 /// 2230 float log2f(float x); // since 8.3 2231 /// 2232 real log2l(real x); // since 10.0 2233 2234 /// 2235 double logb(double x); 2236 /// 2237 float logbf(float x); 2238 /// 2239 real logbl(real x); // since 8.0 2240 2241 /// 2242 pure double modf(double value, double* iptr); 2243 /// 2244 pure float modff(float value, float* iptr); 2245 /// 2246 pure real modfl(real value, real *iptr); // since 8.0 2247 2248 /// 2249 double scalbn(double x, int n); 2250 /// 2251 float scalbnf(float x, int n); 2252 /// 2253 real scalbnl(real x, int n); // since 6.0 2254 2255 /// 2256 double scalbln(double x, c_long n); 2257 /// 2258 float scalblnf(float x, c_long n); 2259 /// 2260 real scalblnl(real x, c_long n); // since 6.0 2261 2262 /// 2263 pure double cbrt(double x); 2264 /// 2265 pure float cbrtf(float x); 2266 /// 2267 pure real cbrtl(real x); // since 9.0 2268 2269 /// 2270 pure double fabs(double x); 2271 /// 2272 pure float fabsf(float x); 2273 /// 2274 pure real fabsl(real x); // since 5.3 2275 2276 /// 2277 double hypot(double x, double y); 2278 /// 2279 float hypotf(float x, float y); 2280 /// 2281 real hypotl(real x, real y); // since 8.0 2282 2283 /// 2284 double pow(double x, double y); 2285 /// 2286 float powf(float x, float y); 2287 /// 2288 real powl(real x, real y); // since 10.4 2289 2290 /// 2291 double sqrt(double x); 2292 /// 2293 float sqrtf(float x); 2294 /// 2295 real sqrtl(real x); // since 8.0 2296 2297 /// 2298 pure double erf(double x); 2299 /// 2300 pure float erff(float x); 2301 /// 2302 pure real erfl(real x); // since 10.1 2303 2304 /// 2305 double erfc(double x); 2306 /// 2307 float erfcf(float x); 2308 /// 2309 real erfcl(real x); // since 10.1 2310 2311 /// 2312 double lgamma(double x); 2313 /// 2314 float lgammaf(float x); 2315 /// 2316 real lgammal(real x); // since 10.2 2317 2318 /// 2319 double tgamma(double x); 2320 /// 2321 float tgammaf(float x); 2322 /// 2323 real tgammal(real x); // since 11.2 2324 2325 /// 2326 pure double ceil(double x); 2327 /// 2328 pure float ceilf(float x); 2329 /// 2330 pure real ceill(real x); // since 5.4 2331 2332 /// 2333 pure double floor(double x); 2334 /// 2335 pure float floorf(float x); 2336 /// 2337 pure real floorl(real x); // since 5.4 2338 2339 /// 2340 pure double nearbyint(double x); 2341 /// 2342 pure float nearbyintf(float x); 2343 /// 2344 pure real nearbyintl(real x); // since 8.0 2345 2346 /// 2347 pure double rint(double x); 2348 /// 2349 pure float rintf(float x); 2350 /// 2351 pure real rintl(real x); // since 8.0 2352 2353 /// 2354 c_long lrint(double x); 2355 /// 2356 c_long lrintf(float x); 2357 /// 2358 c_long lrintl(real x); // since 8.0 2359 2360 /// 2361 long llrint(double x); 2362 /// 2363 long llrintf(float x); 2364 /// 2365 long llrintl(real x); // since 8.0 2366 2367 /// 2368 pure double round(double x); 2369 /// 2370 pure float roundf(float x); 2371 /// 2372 pure real roundl(real x); // since 6.0 2373 2374 /// 2375 c_long lround(double x); 2376 /// 2377 c_long lroundf(float x); 2378 /// 2379 c_long lroundl(real x); // since 6.0 2380 2381 /// 2382 long llround(double x); 2383 /// 2384 long llroundf(float x); 2385 /// 2386 long llroundl(real x); // since 6.0 2387 2388 /// 2389 pure double trunc(double x); 2390 /// 2391 pure float truncf(float x); 2392 /// 2393 pure real truncl(real x); // since 6.0 2394 2395 /// 2396 double fmod(double x, double y); 2397 /// 2398 float fmodf(float x, float y); 2399 /// 2400 real fmodl(real x, real y); // since 8.0 2401 2402 /// 2403 double remainder(double x, double y); 2404 /// 2405 float remainderf(float x, float y); 2406 /// 2407 real remainderl(real x, real y); // since 8.0 2408 2409 /// 2410 double remquo(double x, double y, int* quo); 2411 /// 2412 float remquof(float x, float y, int* quo); 2413 /// 2414 real remquol(real x, real y, int* quo); // since 8.0 2415 2416 /// 2417 pure double copysign(double x, double y); 2418 /// 2419 pure float copysignf(float x, float y); 2420 /// 2421 pure real copysignl(real x, real y); // since 5.3 2422 2423 /// 2424 pure double nan(const char*); // since 8.0 2425 /// 2426 pure float nanf(const char*); // since 8.0 2427 /// 2428 pure real nanl(const char*); // since 8.0 2429 2430 /// 2431 double nextafter(double x, double y); 2432 /// 2433 float nextafterf(float x, float y); 2434 /// 2435 real nextafterl(real x, real y); // since 6.0 2436 2437 /// 2438 double nexttoward(double x, real y); 2439 /// 2440 float nexttowardf(float x, real y); 2441 /// 2442 real nexttowardl(real x, real y); // since 6.0 2443 2444 /// 2445 double fdim(double x, double y); 2446 /// 2447 float fdimf(float x, float y); 2448 /// 2449 real fdiml(real x, real y); // since 5.3 2450 2451 /// 2452 pure double fmax(double x, double y); 2453 /// 2454 pure float fmaxf(float x, float y); 2455 /// 2456 pure real fmaxl(real x, real y); // since 5.3 2457 2458 /// 2459 pure double fmin(double x, double y); 2460 /// 2461 pure float fminf(float x, float y); 2462 /// 2463 pure real fminl(real x, real y); // since 5.3 2464 2465 /// 2466 pure double fma(double x, double y, double z); 2467 /// 2468 pure float fmaf(float x, float y, float z); 2469 /// 2470 pure real fmal(real x, real y, real z); // since 6.0 2471 } 2472 else version (NetBSD) 2473 { 2474 2475 /// 2476 real acosl(real x); 2477 /// 2478 real asinl(real x); 2479 /// 2480 pure real atanl(real x); 2481 /// 2482 real atan2l(real y, real x); 2483 /// 2484 pure real cosl(real x); 2485 /// 2486 pure real sinl(real x); 2487 /// 2488 pure real tanl(real x); 2489 /// 2490 real exp2l(real x); 2491 /// 2492 pure real frexpl(real value, int* exp); 2493 /// 2494 int ilogbl(real x); 2495 /// 2496 real ldexpl(real x, int exp); 2497 /// 2498 real logbl(real x); 2499 /// 2500 pure real modfl(real value, real *iptr); 2501 /// 2502 real scalbnl(real x, int n); 2503 /// 2504 real scalblnl(real x, c_long n); 2505 /// 2506 pure real fabsl(real x); 2507 /// 2508 real hypotl(real x, real y); 2509 /// 2510 real sqrtl(real x); 2511 /// 2512 pure real ceill(real x); 2513 /// 2514 pure real floorl(real x); 2515 /// 2516 pure real nearbyintl(real x); 2517 /// 2518 pure real rintl(real x); 2519 /// 2520 extern(D) c_long lrintl(real x) { return cast(c_long)rintl(x); } 2521 /// 2522 pure real roundl(real x); 2523 /// 2524 extern(D) c_long lroundl(real x) { return cast(c_long)roundl(x);} 2525 /// 2526 extern(D) long llroundl(real x) { return cast(long)roundl(x);} 2527 /// 2528 pure real truncl(real x); 2529 /// 2530 real fmodl(real x, real y); 2531 /// 2532 real remainderl(real x, real y) { return remainder(x,y); } 2533 /// 2534 real remquol(real x, real y, int* quo){ return remquo(x,y,quo); } 2535 /// 2536 pure real copysignl(real x, real y); 2537 /// 2538 pure double nan(char* tagp); 2539 /// 2540 pure float nanf(char* tagp); 2541 /// 2542 pure real nanl(char* tagp); 2543 /// 2544 real nextafterl(real x, real y); 2545 /// 2546 extern(D) real nexttowardl(real x, real y) { return nexttoward(cast(double) x, cast(double) y); } 2547 /// 2548 real fdiml(real x, real y); 2549 /// 2550 pure real fmaxl(real x, real y); 2551 /// 2552 pure real fminl(real x, real y); 2553 /// 2554 pure real fmal(real x, real y, real z); 2555 2556 /// 2557 double acos(double x); 2558 /// 2559 float acosf(float x); 2560 2561 /// 2562 double asin(double x); 2563 /// 2564 float asinf(float x); 2565 2566 /// 2567 pure double atan(double x); 2568 /// 2569 pure float atanf(float x); 2570 2571 /// 2572 double atan2(double y, double x); 2573 /// 2574 float atan2f(float y, float x); 2575 2576 /// 2577 pure double cos(double x); 2578 /// 2579 pure float cosf(float x); 2580 2581 /// 2582 pure double sin(double x); 2583 /// 2584 pure float sinf(float x); 2585 2586 /// 2587 pure double tan(double x); 2588 /// 2589 pure float tanf(float x); 2590 2591 /// 2592 double acosh(double x); 2593 /// 2594 float acoshf(float x); 2595 /// 2596 real acoshl(real x); 2597 2598 /// 2599 pure double asinh(double x); 2600 /// 2601 pure float asinhf(float x); 2602 /// 2603 pure real asinhl(real x); 2604 2605 /// 2606 double atanh(double x); 2607 /// 2608 float atanhf(float x); 2609 /// 2610 real atanhl(real x); 2611 2612 /// 2613 double cosh(double x); 2614 /// 2615 float coshf(float x); 2616 /// 2617 real coshl(real x); 2618 2619 /// 2620 double sinh(double x); 2621 /// 2622 float sinhf(float x); 2623 /// 2624 real sinhl(real x); 2625 2626 /// 2627 pure double tanh(double x); 2628 /// 2629 pure float tanhf(float x); 2630 /// 2631 pure real tanhl(real x); 2632 2633 /// 2634 double exp(double x); 2635 /// 2636 float expf(float x); 2637 /// 2638 real expl(real x); 2639 2640 /// 2641 double exp2(double x); 2642 /// 2643 float exp2f(float x); 2644 2645 /// 2646 double expm1(double x); 2647 /// 2648 float expm1f(float x); 2649 /// 2650 real expm1l(real x) { return expm1(cast(double) x); } 2651 2652 /// 2653 pure double frexp(double value, int* exp); 2654 /// 2655 pure float frexpf(float value, int* exp); 2656 2657 /// 2658 int ilogb(double x); 2659 /// 2660 int ilogbf(float x); 2661 2662 /// 2663 double ldexp(double x, int exp); 2664 /// 2665 float ldexpf(float x, int exp); 2666 2667 /// 2668 double log(double x); 2669 /// 2670 float logf(float x); 2671 /// NetBSD has no logl. It is just alias log(double) 2672 real logl(real x) 2673 { 2674 if (x<0) return real.nan; 2675 if (x==0) return -real.infinity; 2676 if (isnan(x) || isinf(x)) return x; 2677 real rs = 0; 2678 if (x>double.max) 2679 { 2680 immutable MAX = log(double.max); 2681 for (; x>double.max; x /= double.max) 2682 rs += MAX; 2683 } 2684 else if (x<double.min_normal) 2685 { 2686 immutable MIN = log(double.min_normal); 2687 for (; x<double.min_normal; x /= double.min_normal) 2688 rs += MIN; 2689 } 2690 rs += log(x); 2691 return rs; 2692 } 2693 2694 /// 2695 double log10(double x); 2696 /// 2697 float log10f(float x); 2698 ///NetBSD has no log10l. It is just alias log(double) 2699 real log10l(real x) 2700 { 2701 if (x<0) return real.nan; 2702 if (x==0) return -real.infinity; 2703 if (isnan(x) || isinf(x)) return x; 2704 2705 real rs = 0; 2706 if (x>double.max) 2707 { 2708 immutable MAX = log10(double.max); 2709 for (; x>double.max; x /= double.max) 2710 rs += MAX; 2711 } 2712 else if (x<double.min_normal) 2713 { 2714 immutable MIN = log10(double.min_normal); 2715 for (; x<double.min_normal; x /= double.min_normal) 2716 rs += MIN; 2717 } 2718 rs += log10(x); 2719 return rs; 2720 } 2721 2722 2723 /// 2724 double log1p(double x); 2725 /// 2726 float log1pf(float x); 2727 /// 2728 extern(D) real log1pl(real x) { return log1p(cast(double) x); } 2729 2730 private enum real ONE_LN2 = 1 / 0x1.62e42fefa39ef358p-1L; 2731 /// 2732 extern(D) double log2(double x) { return log(x) * ONE_LN2; } 2733 /// 2734 extern(D) float log2f(float x) { return logf(x) * ONE_LN2; } 2735 /// 2736 real log2l(real x) { return logl(x) * ONE_LN2; } 2737 2738 /// 2739 double logb(double x); 2740 /// 2741 float logbf(float x); 2742 2743 /// 2744 pure double modf(double value, double* iptr); 2745 /// 2746 pure float modff(float value, float* iptr); 2747 2748 /// 2749 double scalbn(double x, int n); 2750 /// 2751 float scalbnf(float x, int n); 2752 2753 /// 2754 double scalbln(double x, c_long n); 2755 /// 2756 float scalblnf(float x, c_long n); 2757 2758 /// 2759 pure double cbrt(double x); 2760 /// 2761 pure float cbrtf(float x); 2762 /// 2763 pure real cbrtl(real x); 2764 2765 /// 2766 pure double fabs(double x); 2767 /// 2768 pure float fabsf(float x); 2769 2770 /// 2771 double hypot(double x, double y); 2772 /// 2773 float hypotf(float x, float y); 2774 2775 /// 2776 double pow(double x, double y); 2777 /// 2778 float powf(float x, float y); 2779 /// 2780 real powl(real x, real y); 2781 2782 /// 2783 double sqrt(double x); 2784 /// 2785 float sqrtf(float x); 2786 2787 /// 2788 pure double erf(double x); 2789 /// 2790 pure float erff(float x); 2791 /// 2792 extern(D) pure real erfl(real x) { return erf(cast(double) x); } 2793 2794 /// 2795 double erfc(double x); 2796 /// 2797 float erfcf(float x); 2798 /// 2799 real erfcl(real x) { return erfc(cast(double) x); } 2800 2801 /// 2802 double lgamma(double x); 2803 /// 2804 float lgammaf(float x); 2805 /// 2806 real lgammal(real x){ return lgamma(x); } 2807 2808 /// 2809 double tgamma(double x); 2810 /// 2811 float tgammaf(float x); 2812 /// 2813 real tgammal(real x){ return tgamma(cast(double) x); } 2814 2815 /// 2816 pure double ceil(double x); 2817 /// 2818 pure float ceilf(float x); 2819 2820 /// 2821 pure double floor(double x); 2822 /// 2823 pure float floorf(float x); 2824 2825 /// 2826 pure double nearbyint(double x); 2827 /// 2828 pure float nearbyintf(float x); 2829 2830 /// 2831 pure double rint(double x); 2832 /// 2833 pure float rintf(float x); 2834 2835 /// 2836 c_long lrint(double x); 2837 /// 2838 c_long lrintf(float x); 2839 2840 /// 2841 long llrint(double x); 2842 /// 2843 long llrintf(float x); 2844 /// 2845 extern(D) long llrintl(real x) { return cast(long)rintl(x); } 2846 2847 /// 2848 pure double round(double x); 2849 /// 2850 pure float roundf(float x); 2851 2852 /// 2853 c_long lround(double x); 2854 /// 2855 c_long lroundf(float x); 2856 2857 /// 2858 long llround(double x); 2859 /// 2860 long llroundf(float x); 2861 2862 /// 2863 pure double trunc(double x); 2864 /// 2865 pure float truncf(float x); 2866 2867 /// 2868 double fmod(double x, double y); 2869 /// 2870 float fmodf(float x, float y); 2871 2872 /// 2873 double remainder(double x, double y); 2874 /// 2875 float remainderf(float x, float y); 2876 2877 /// 2878 double remquo(double x, double y, int* quo); 2879 /// 2880 float remquof(float x, float y, int* quo); 2881 2882 /// 2883 pure double copysign(double x, double y); 2884 /// 2885 pure float copysignf(float x, float y); 2886 2887 /// 2888 double nextafter(double x, double y); 2889 /// 2890 float nextafterf(float x, float y); 2891 2892 /// 2893 double nexttoward(double x, real y); 2894 /// 2895 float nexttowardf(float x, real y); 2896 2897 /// 2898 double fdim(double x, double y); 2899 /// 2900 float fdimf(float x, float y); 2901 2902 /// 2903 pure double fmax(double x, double y); 2904 /// 2905 pure float fmaxf(float x, float y); 2906 2907 /// 2908 pure double fmin(double x, double y); 2909 /// 2910 pure float fminf(float x, float y); 2911 2912 /// 2913 pure double fma(double x, double y, double z); 2914 /// 2915 pure float fmaf(float x, float y, float z); 2916 } 2917 else version (OpenBSD) 2918 { 2919 /// 2920 double acos(double x); 2921 /// 2922 double asin(double x); 2923 /// 2924 pure double atan(double x); 2925 /// 2926 double atan2(double, double); 2927 /// 2928 pure double cos(double x); 2929 /// 2930 pure double sin(double x); 2931 /// 2932 pure double tan(double x); 2933 /// 2934 double cosh(double x); 2935 /// 2936 double sinh(double x); 2937 /// 2938 pure double tanh(double x); 2939 /// 2940 double exp(double x); 2941 /// 2942 pure double frexp(double, int *exp); 2943 /// 2944 double ldexp(double, int exp); 2945 /// 2946 double log(double x); 2947 /// 2948 double log10(double x); 2949 /// 2950 pure double modf(double x, double *iptr); 2951 /// 2952 double pow(double x, double y); 2953 /// 2954 double sqrt(double x); 2955 /// 2956 pure double ceil(double x); 2957 /// 2958 pure double fabs(double x); 2959 /// 2960 pure double floor(double x); 2961 /// 2962 double fmod(double x, double); 2963 /// 2964 double acosh(double x); 2965 /// 2966 pure double asinh(double x); 2967 /// 2968 double atanh(double x); 2969 /// 2970 double exp2(double x); 2971 /// 2972 double expm1(double x); 2973 /// 2974 int ilogb(double x); 2975 /// 2976 double log1p(double x); 2977 /// 2978 double log2(double x); 2979 /// 2980 double logb(double x); 2981 /// 2982 double scalbn(double x, int n); 2983 /// 2984 double scalbln(double x, c_long n); 2985 /// 2986 pure double cbrt(double x); 2987 /// 2988 double hypot(double x, double y); 2989 /// 2990 pure double erf(double x); 2991 /// 2992 double erfc(double x); 2993 /// 2994 double lgamma(double x); 2995 /// 2996 double tgamma(double x); 2997 /// 2998 pure double nearbyint(double x); 2999 /// 3000 pure double rint(double x); 3001 /// 3002 c_long lrint(double x); 3003 /// 3004 long llrint(double x); 3005 /// 3006 pure double round(double x); 3007 /// 3008 c_long lround(double x); 3009 /// 3010 long llround(double x); 3011 /// 3012 pure double trunc(double x); 3013 /// 3014 double remainder(double x , double y); 3015 /// 3016 double remquo(double x, double y, int * quo); 3017 /// 3018 pure double copysign(double x, double y); 3019 /// 3020 pure double nan(const char *); 3021 /// 3022 double nextafter(double x, double y); 3023 /// 3024 double nexttoward(double x, real y); 3025 /// 3026 double fdim(double x, double y); 3027 /// 3028 pure double fmax(double x, double y); 3029 /// 3030 pure double fmin(double x, double y); 3031 /// 3032 pure double fma(double x, double y, double z); 3033 /// 3034 double j0(double x); 3035 /// 3036 double j1(double x); 3037 /// 3038 double jn(int, double); 3039 /// 3040 double y0(double x); 3041 /// 3042 double y1(double x); 3043 /// 3044 double yn(int, double); 3045 /// 3046 double gamma(double x); 3047 /// 3048 double scalb(double x, double y); 3049 /// 3050 double drem(double x, double y); 3051 /// 3052 int finite(double x); 3053 /// 3054 double gamma_r(double x, int *); 3055 /// 3056 double lgamma_r(double x, int *); 3057 /// 3058 double significand(double x); 3059 3060 /// 3061 float acosf(float x); 3062 /// 3063 float asinf(float x); 3064 /// 3065 pure float atanf(float x); 3066 /// 3067 float atan2f(float x, float y); 3068 /// 3069 pure float cosf(float x); 3070 /// 3071 pure float sinf(float x); 3072 /// 3073 pure float tanf(float x); 3074 /// 3075 float acoshf(float x); 3076 /// 3077 pure float asinhf(float x); 3078 /// 3079 float atanhf(float x); 3080 /// 3081 float coshf(float x); 3082 /// 3083 float sinhf(float x); 3084 /// 3085 pure float tanhf(float x); 3086 /// 3087 float expf(float x); 3088 /// 3089 float exp2f(float x); 3090 /// 3091 float expm1f(float x); 3092 /// 3093 pure float frexpf(float x, int *exp); 3094 /// 3095 int ilogbf(float x); 3096 /// 3097 float ldexpf(float x, int exp); 3098 /// 3099 float logf(float x); 3100 /// 3101 float log10f(float x); 3102 /// 3103 float log1pf(float x); 3104 /// 3105 float log2f(float x); 3106 /// 3107 float logbf(float x); 3108 /// 3109 pure float modff(float x, float *iptr); 3110 /// 3111 float scalbnf(float x, int y); 3112 /// 3113 float scalblnf(float x, c_long y); 3114 /// 3115 pure float cbrtf(float x); 3116 /// 3117 pure float fabsf(float x); 3118 /// 3119 float hypotf(float x, float y); 3120 /// 3121 float powf(float x, float y); 3122 /// 3123 float sqrtf(float x); 3124 /// 3125 pure float erff(float x); 3126 /// 3127 float erfcf(float x); 3128 /// 3129 float lgammaf(float x); 3130 /// 3131 float tgammaf(float x); 3132 /// 3133 pure float ceilf(float x); 3134 /// 3135 pure float floorf(float x); 3136 /// 3137 pure float nearbyintf(float x); 3138 /// 3139 pure float rintf(float x); 3140 /// 3141 c_long lrintf(float x); 3142 /// 3143 long llrintf(float x); 3144 /// 3145 pure float roundf(float x); 3146 /// 3147 c_long lroundf(float x); 3148 /// 3149 long llroundf(float x); 3150 /// 3151 pure float truncf(float x); 3152 /// 3153 pure float fmodf(float x, float y); 3154 /// 3155 float remainderf(float x, float y); 3156 /// 3157 float remquof(float x, float y, int *iptr); 3158 /// 3159 pure float copysignf(float x, float y); 3160 /// 3161 pure float nanf(const char *); 3162 /// 3163 float nextafterf(float x, float y); 3164 /// 3165 float nexttowardf(float x, real y); 3166 /// 3167 float fdimf(float x, float y); 3168 /// 3169 pure float fmaxf(float x, float y); 3170 /// 3171 pure float fminf(float x, float y); 3172 /// 3173 pure float fmaf(float x, float y, float z); 3174 /// 3175 float j0f(float x); 3176 /// 3177 float j1f(float x); 3178 /// 3179 float jnf(int, float); 3180 /// 3181 float scalbf(float x, float); 3182 /// 3183 float y0f(float x); 3184 /// 3185 float y1f(float x); 3186 /// 3187 float ynf(int, float); 3188 /// 3189 float gammaf(float x); 3190 /// 3191 float dremf(float x, float); 3192 /// 3193 pure int finitef(float x); 3194 /// 3195 pure int isinff(float x); 3196 /// 3197 pure int isnanf(float x); 3198 /// 3199 float gammaf_r(float x, int *); 3200 /// 3201 float lgammaf_r(float x, int *); 3202 /// 3203 float significandf(float x); 3204 /// 3205 3206 /// 3207 pure real acosl(real x); 3208 /// 3209 pure real asinl(real x); 3210 /// 3211 pure real atanl(real x); 3212 /// 3213 real atan2l(real y, real x); 3214 /// 3215 pure real cosl(real x); 3216 /// 3217 pure real sinl(real x); 3218 /// 3219 pure real tanl(real x); 3220 /// 3221 real acoshl(real x); 3222 /// 3223 pure real asinhl(real x); 3224 /// 3225 real atanhl(real x); 3226 /// 3227 real coshl(real x); 3228 /// 3229 real sinhl(real x); 3230 /// 3231 pure real tanhl(real x); 3232 /// 3233 real expl(real x); 3234 /// 3235 real exp2l(real x); 3236 /// 3237 real expm1l(real x); 3238 /// 3239 pure real frexpl(real x, int *exp); 3240 /// 3241 int ilogbl(real x); 3242 /// 3243 real ldexpl(real x, int exp); 3244 /// 3245 real logl(real x); 3246 /// 3247 real log10l(real x); 3248 /// 3249 real log1pl(real x); 3250 /// 3251 real log2l(real x); 3252 /// 3253 real logbl(real x); 3254 /// 3255 pure real modfl(real x, real *iptr); 3256 /// 3257 real scalbnl(real x, int y); 3258 /// 3259 real scalblnl(real x, c_long y); 3260 /// 3261 pure real cbrtl(real x); 3262 /// 3263 pure real fabsl(real x); 3264 /// 3265 real hypotl(real x, real y); 3266 /// 3267 real powl(real x, real y); 3268 /// 3269 real sqrtl(real x); 3270 /// 3271 pure real erfl(real x); 3272 /// 3273 real erfcl(real x); 3274 /// 3275 real lgammal(real x); 3276 /// 3277 real tgammal(real x); 3278 /// 3279 pure real ceill(real x); 3280 /// 3281 pure real floorl(real x); 3282 /// 3283 pure real nearbyintl(real x); 3284 /// 3285 pure real rintl(real x); 3286 /// 3287 c_long lrintl(real x); 3288 /// 3289 long llrintl(real x); 3290 /// 3291 pure real roundl(real x); 3292 /// 3293 c_long lroundl(real x); 3294 /// 3295 long llroundl(real x); 3296 /// 3297 pure real truncl(real x); 3298 /// 3299 pure real fmodl(real x, real); 3300 /// 3301 pure real remainderl(real x, real); 3302 /// 3303 pure real remquol(real x, real y, int *iptr); 3304 /// 3305 pure real copysignl(real x, real y); 3306 /// 3307 pure real nanl(const char *); 3308 /// 3309 real nextafterl(real x, real y); 3310 /// 3311 real nexttowardl(real x, real y); 3312 /// 3313 real fdiml(real x, real y); 3314 /// 3315 pure real fmaxl(real x, real y); 3316 /// 3317 pure real fminl(real x, real y); 3318 /// 3319 pure real fmal(real x, real, real); 3320 } 3321 else version (DragonFlyBSD) 3322 { 3323 /* double */ 3324 double acos(double x); 3325 double asin(double x); 3326 pure double atan(double x); 3327 double atan2(double, double); 3328 pure double cos(double x); 3329 pure double sin(double x); 3330 pure double tan(double x); 3331 3332 double cosh(double x); 3333 double sinh(double x); 3334 pure double tanh(double x); 3335 3336 double exp(double x); 3337 pure double frexp(double, int *exp); 3338 double ldexp(double, int exp); 3339 double log(double x); 3340 double log10(double x); 3341 pure double modf(double x, double *iptr); 3342 3343 double pow(double x, double y); 3344 double sqrt(double x); 3345 3346 pure double ceil(double x); 3347 pure double fabs(double x); 3348 pure double floor(double x); 3349 double fmod(double x, double); 3350 3351 double acosh(double x); 3352 pure double asinh(double x); 3353 double atanh(double x); 3354 3355 double exp2(double x); 3356 double expm1(double x); 3357 int ilogb(double x); 3358 double log1p(double x); 3359 double log2(double x); 3360 double logb(double x); 3361 double scalbn(double x, int n); 3362 double scalbln(double x, c_long n); 3363 3364 pure double cbrt(double x); 3365 double hypot(double x, double y); 3366 3367 pure double erf(double x); 3368 double erfc(double x); 3369 double lgamma(double x); 3370 double tgamma(double x); 3371 3372 pure double nearbyint(double x); 3373 pure double rint(double x); 3374 c_long lrint(double x); 3375 long llrint(double x); 3376 pure double round(double x); 3377 c_long lround(double x); 3378 long llround(double x); 3379 pure double trunc(double x); 3380 3381 double remainder(double x , double y); 3382 double remquo(double x, double y, int * quo); 3383 3384 pure double copysign(double x, double y); 3385 pure double nan(const char *); 3386 double nextafter(double x, double y); 3387 double nexttoward(double x, real y); 3388 3389 double fdim(double x, double y); 3390 pure double fmax(double x, double y); 3391 pure double fmin(double x, double y); 3392 3393 pure double fma(double x, double y, double z); 3394 3395 double j0(double x); 3396 double j1(double x); 3397 double jn(int, double); 3398 double y0(double x); 3399 double y1(double x); 3400 double yn(int, double); 3401 3402 double gamma(double x); 3403 double scalb(double x, double y); 3404 3405 double drem(double x, double y); 3406 int finite(double x); 3407 double gamma_r(double x, int *); 3408 double lgamma_r(double x, int *); 3409 3410 double significand(double x); 3411 3412 /* float */ 3413 float acosf(float x); 3414 float asinf(float x); 3415 pure float atanf(float x); 3416 float atan2f(float x, float y); 3417 pure float cosf(float x); 3418 pure float sinf(float x); 3419 pure float tanf(float x); 3420 3421 float acoshf(float x); 3422 pure float asinhf(float x); 3423 float atanhf(float x); 3424 float coshf(float x); 3425 float sinhf(float x); 3426 pure float tanhf(float x); 3427 3428 float expf(float x); 3429 float exp2f(float x); 3430 float expm1f(float x); 3431 pure float frexpf(float x, int *exp); 3432 int ilogbf(float x); 3433 float ldexpf(float x, int exp); 3434 float logf(float x); 3435 float log10f(float x); 3436 float log1pf(float x); 3437 float log2f(float x); 3438 float logbf(float x); 3439 pure float modff(float x, float *iptr); 3440 float scalbnf(float x, int y); 3441 float scalblnf(float x, c_long y); 3442 3443 pure float cbrtf(float x); 3444 pure float fabsf(float x); 3445 float hypotf(float x, float y); 3446 float powf(float x, float y); 3447 float sqrtf(float x); 3448 3449 pure float erff(float x); 3450 float erfcf(float x); 3451 float lgammaf(float x); 3452 float tgammaf(float x); 3453 3454 pure float ceilf(float x); 3455 pure float floorf(float x); 3456 pure float nearbyintf(float x); 3457 pure float rintf(float x); 3458 c_long lrintf(float x); 3459 long llrintf(float x); 3460 pure float roundf(float x); 3461 c_long lroundf(float x); 3462 long llroundf(float x); 3463 pure float truncf(float x); 3464 3465 pure float fmodf(float x, float y); 3466 float remainderf(float x, float y); 3467 float remquof(float x, float y, int *iptr); 3468 3469 pure float copysignf(float x, float y); 3470 pure float nanf(const char *); 3471 float nextafterf(float x, float y); 3472 float nexttowardf(float x, real y); 3473 3474 float fdimf(float x, float y); 3475 pure float fmaxf(float x, float y); 3476 pure float fminf(float x, float y); 3477 3478 pure float fmaf(float x, float y, float z); 3479 3480 float j0f(float x); 3481 float j1f(float x); 3482 float jnf(int, float); 3483 float scalbf(float x, float); 3484 float y0f(float x); 3485 float y1f(float x); 3486 float ynf(int, float); 3487 float gammaf(float x); 3488 float dremf(float x, float); 3489 pure int finitef(float x); 3490 pure int isinff(float x); 3491 pure int isnanf(float x); 3492 3493 float gammaf_r(float x, int *); 3494 float lgammaf_r(float x, int *); 3495 float significandf(float x); 3496 3497 /* real */ 3498 pure real acosl(real x); 3499 pure real asinl(real x); 3500 pure real atanl(real x); 3501 real atan2l(real y, real x); 3502 pure real cosl(real x); 3503 pure real sinl(real x); 3504 pure real tanl(real x); 3505 3506 real acoshl(real x); 3507 pure real asinhl(real x); 3508 real atanhl(real x); 3509 real coshl(real x); 3510 real sinhl(real x); 3511 pure real tanhl(real x); 3512 3513 real expl(real x); 3514 real exp2l(real x); 3515 real expm1l(real x); 3516 pure real frexpl(real x, int *exp); 3517 int ilogbl(real x); 3518 real ldexpl(real x, int exp); 3519 real logl(real x); 3520 real log10l(real x); 3521 real log1pl(real x); 3522 real log2l(real x); 3523 real logbl(real x); 3524 pure real modfl(real x, real *iptr); 3525 real scalbnl(real x, int y); 3526 real scalblnl(real x, c_long y); 3527 3528 pure real cbrtl(real x); 3529 pure real fabsl(real x); 3530 real hypotl(real x, real y); 3531 real powl(real x, real y); 3532 real sqrtl(real x); 3533 3534 pure real erfl(real x); 3535 real erfcl(real x); 3536 real lgammal(real x); 3537 real tgammal(real x); 3538 3539 pure real ceill(real x); 3540 pure real floorl(real x); 3541 pure real nearbyintl(real x); 3542 pure real rintl(real x); 3543 c_long lrintl(real x); 3544 long llrintl(real x); 3545 pure real roundl(real x); 3546 c_long lroundl(real x); 3547 long llroundl(real x); 3548 pure real truncl(real x); 3549 3550 pure real fmodl(real x, real); 3551 pure real remainderl(real x, real); 3552 pure real remquol(real x, real y, int *iptr); 3553 3554 pure real copysignl(real x, real y); 3555 pure real nanl(const char *); 3556 real nextafterl(real x, real y); 3557 real nexttowardl(real x, real y); 3558 3559 real fdiml(real x, real y); 3560 pure real fmaxl(real x, real y); 3561 pure real fminl(real x, real y); 3562 3563 pure real fmal(real x, real, real); 3564 } 3565 else version (CRuntime_Bionic) 3566 { 3567 /// 3568 double acos(double x); 3569 /// 3570 float acosf(float x); 3571 /// Added since Lollipop 3572 real acosl(real x); 3573 3574 /// 3575 double asin(double x); 3576 /// 3577 float asinf(float x); 3578 /// Added since Lollipop 3579 real asinl(real x); 3580 3581 /// 3582 pure double atan(double x); 3583 /// 3584 pure float atanf(float x); 3585 /// Added since Lollipop 3586 pure real atanl(real x); 3587 3588 /// 3589 double atan2(double y, double x); 3590 /// 3591 float atan2f(float y, float x); 3592 /// Added since Lollipop 3593 real atan2l(real y, real x); 3594 3595 /// 3596 pure double cos(double x); 3597 /// 3598 pure float cosf(float x); 3599 /// 3600 pure real cosl(real x); 3601 3602 /// 3603 pure double sin(double x); 3604 /// 3605 pure float sinf(float x); 3606 /// Added since Lollipop 3607 pure real sinl(real x); 3608 3609 /// 3610 pure double tan(double x); 3611 /// 3612 pure float tanf(float x); 3613 /// Added since Lollipop 3614 pure real tanl(real x); 3615 3616 /// 3617 double acosh(double x); 3618 /// 3619 float acoshf(float x); 3620 /// Added since Lollipop 3621 real acoshl(real x); 3622 3623 /// 3624 pure double asinh(double x); 3625 /// 3626 pure float asinhf(float x); 3627 /// Added since Lollipop 3628 pure real asinhl(real x); 3629 3630 /// 3631 double atanh(double x); 3632 /// 3633 float atanhf(float x); 3634 /// Added since Lollipop 3635 real atanhl(real x); 3636 3637 /// 3638 double cosh(double x); 3639 /// 3640 float coshf(float x); 3641 /// Added since Lollipop 3642 real coshl(real x); 3643 3644 /// 3645 double sinh(double x); 3646 /// 3647 float sinhf(float x); 3648 /// Added since Lollipop 3649 real sinhl(real x); 3650 3651 /// 3652 pure double tanh(double x); 3653 /// 3654 pure float tanhf(float x); 3655 /// Added since Lollipop 3656 pure real tanhl(real x); 3657 3658 /// 3659 double exp(double x); 3660 /// 3661 float expf(float x); 3662 /// 3663 real expl(real x); 3664 3665 /// 3666 double exp2(double x); 3667 /// 3668 float exp2f(float x); 3669 /// Added since Lollipop 3670 real exp2l(real x); 3671 3672 /// 3673 double expm1(double x); 3674 /// 3675 float expm1f(float x); 3676 /// Added since Lollipop 3677 real expm1l(real x); 3678 3679 /// 3680 pure double frexp(double value, int* exp); 3681 /// 3682 pure float frexpf(float value, int* exp); 3683 /// Added since Lollipop 3684 pure real frexpl(real value, int* exp); 3685 3686 /// 3687 int ilogb(double x); 3688 /// 3689 int ilogbf(float x); 3690 /// 3691 int ilogbl(real x); 3692 3693 /// 3694 double ldexp(double x, int exp); 3695 /// 3696 float ldexpf(float x, int exp); 3697 /// 3698 real ldexpl(real x, int exp); 3699 3700 /// 3701 double log(double x); 3702 /// 3703 float logf(float x); 3704 /// Added since Lollipop 3705 real logl(real x); 3706 3707 /// 3708 double log10(double x); 3709 /// 3710 float log10f(float x); 3711 /// Added since Lollipop 3712 real log10l(real x); 3713 3714 /// 3715 double log1p(double x); 3716 /// 3717 float log1pf(float x); 3718 /// Added since Lollipop 3719 real log1pl(real x); 3720 3721 /// 3722 double log2(double x); 3723 /// 3724 float log2f(float x); 3725 /// 3726 real log2l(real x); 3727 3728 /// 3729 double logb(double x); 3730 /// 3731 float logbf(float x); 3732 /// 3733 real logbl(real x); 3734 3735 /// 3736 pure double modf(double value, double* iptr); 3737 /// 3738 pure float modff(float value, float* iptr); 3739 /// Added since Lollipop 3740 pure real modfl(real value, real *iptr); 3741 3742 /// 3743 double scalbn(double x, int n); 3744 /// 3745 float scalbnf(float x, int n); 3746 /// 3747 real scalbnl(real x, int n); 3748 3749 /// 3750 double scalbln(double x, c_long n); 3751 /// 3752 float scalblnf(float x, c_long n); 3753 /// 3754 real scalblnl(real x, c_long n); 3755 3756 /// 3757 pure double cbrt(double x); 3758 /// 3759 pure float cbrtf(float x); 3760 /// Added since Lollipop 3761 pure real cbrtl(real x); 3762 3763 /// 3764 pure double fabs(double x); 3765 /// 3766 pure float fabsf(float x); 3767 /// 3768 pure real fabsl(real x); 3769 3770 /// 3771 double hypot(double x, double y); 3772 /// 3773 float hypotf(float x, float y); 3774 /// Added since Lollipop 3775 real hypotl(real x, real y); 3776 3777 /// 3778 double pow(double x, double y); 3779 /// 3780 float powf(float x, float y); 3781 /// Added since Lollipop 3782 real powl(real x, real y); 3783 3784 /// 3785 double sqrt(double x); 3786 /// 3787 float sqrtf(float x); 3788 /// Added since Lollipop 3789 real sqrtl(real x); 3790 3791 /// 3792 pure double erf(double x); 3793 /// 3794 pure float erff(float x); 3795 /// Added since Lollipop 3796 pure real erfl(real x); 3797 3798 /// 3799 double erfc(double x); 3800 /// 3801 float erfcf(float x); 3802 /// Added since Lollipop 3803 real erfcl(real x); 3804 3805 /// 3806 double lgamma(double x); 3807 /// 3808 float lgammaf(float x); 3809 /// Added since Lollipop 3810 real lgammal(real x); 3811 3812 /// 3813 double tgamma(double x); 3814 /// 3815 float tgammaf(float x); 3816 /// Added since Lollipop 3817 real tgammal(real x); 3818 3819 /// 3820 pure double ceil(double x); 3821 /// 3822 pure float ceilf(float x); 3823 /// 3824 pure real ceill(real x); 3825 3826 /// 3827 pure double floor(double x); 3828 /// 3829 pure float floorf(float x); 3830 /// 3831 pure real floorl(real x); 3832 3833 /// 3834 pure double nearbyint(double x); 3835 /// 3836 pure float nearbyintf(float x); 3837 /// Added since Lollipop 3838 pure real nearbyintl(real x); 3839 3840 /// 3841 pure double rint(double x); 3842 /// 3843 pure float rintf(float x); 3844 /// Added since Lollipop 3845 pure real rintl(real x); 3846 3847 /// 3848 c_long lrint(double x); 3849 /// 3850 c_long lrintf(float x); 3851 /// Added since Lollipop 3852 c_long lrintl(real x); 3853 3854 /// 3855 long llrint(double x); 3856 /// 3857 long llrintf(float x); 3858 /// Added since Lollipop 3859 long llrintl(real x); 3860 3861 /// 3862 pure double round(double x); 3863 /// 3864 pure float roundf(float x); 3865 /// 3866 pure real roundl(real x); 3867 3868 /// 3869 c_long lround(double x); 3870 /// 3871 c_long lroundf(float x); 3872 /// 3873 c_long lroundl(real x); 3874 3875 /// 3876 long llround(double x); 3877 /// 3878 long llroundf(float x); 3879 /// 3880 long llroundl(real x); 3881 3882 /// 3883 pure double trunc(double x); 3884 /// 3885 pure float truncf(float x); 3886 /// 3887 pure real truncl(real x); 3888 3889 /// 3890 double fmod(double x, double y); 3891 /// 3892 float fmodf(float x, float y); 3893 /// Added since Lollipop 3894 real fmodl(real x, real y); 3895 3896 /// 3897 double remainder(double x, double y); 3898 /// 3899 float remainderf(float x, float y); 3900 /// Added since Lollipop 3901 real remainderl(real x, real y); 3902 3903 /// 3904 double remquo(double x, double y, int* quo); 3905 /// 3906 float remquof(float x, float y, int* quo); 3907 /// Added since Lollipop 3908 real remquol(real x, real y, int* quo); 3909 3910 /// 3911 pure double copysign(double x, double y); 3912 /// 3913 pure float copysignf(float x, float y); 3914 /// 3915 pure real copysignl(real x, real y); 3916 3917 /// 3918 pure double nan(char* tagp); 3919 /// 3920 pure float nanf(char* tagp); 3921 /// 3922 pure real nanl(char* tagp); 3923 3924 /// 3925 double nextafter(double x, double y); 3926 /// 3927 float nextafterf(float x, float y); 3928 /// Added since Lollipop 3929 real nextafterl(real x, real y); 3930 3931 /// 3932 double nexttoward(double x, real y); 3933 /// 3934 float nexttowardf(float x, real y); 3935 /// 3936 real nexttowardl(real x, real y); 3937 3938 /// 3939 double fdim(double x, double y); 3940 /// 3941 float fdimf(float x, float y); 3942 /// 3943 real fdiml(real x, real y); 3944 3945 /// 3946 pure double fmax(double x, double y); 3947 /// 3948 pure float fmaxf(float x, float y); 3949 /// 3950 pure real fmaxl(real x, real y); 3951 3952 /// 3953 pure double fmin(double x, double y); 3954 /// 3955 pure float fminf(float x, float y); 3956 /// 3957 pure real fminl(real x, real y); 3958 3959 /// 3960 pure double fma(double x, double y, double z); 3961 /// 3962 pure float fmaf(float x, float y, float z); 3963 /// Added since Lollipop 3964 pure real fmal(real x, real y, real z); 3965 } 3966 else version (CRuntime_UClibc) 3967 { 3968 // uClibc wraps 'long double' to double, so we do the same for 'real' 3969 3970 /// 3971 double acos(double x); 3972 /// 3973 float acosf(float x); 3974 /// 3975 extern(D) real acosl(real x) { return acos(cast(double) x); } 3976 3977 /// 3978 double asin(double x); 3979 /// 3980 float asinf(float x); 3981 /// 3982 extern(D) real asinl(real x) { return asin(cast(double) x); } 3983 3984 /// 3985 pure double atan(double x); 3986 /// 3987 pure float atanf(float x); 3988 /// 3989 extern(D) pure real atanl(real x) { return atan(cast(double) x); } 3990 3991 /// 3992 double atan2(double y, double x); 3993 /// 3994 float atan2f(float y, float x); 3995 /// 3996 extern(D) real atan2l(real y, real x) { return atan2(cast(double) y, cast(double) x); } 3997 3998 /// 3999 pure double cos(double x); 4000 /// 4001 pure float cosf(float x); 4002 /// 4003 extern(D) pure real cosl(real x) { return cos(cast(double) x); } 4004 4005 /// 4006 pure double sin(double x); 4007 /// 4008 pure float sinf(float x); 4009 /// 4010 extern(D) pure real sinl(real x) { return sin(cast(double) x); } 4011 4012 /// 4013 pure double tan(double x); 4014 /// 4015 pure float tanf(float x); 4016 /// 4017 extern(D) pure real tanl(real x) { return tan(cast(double) x); } 4018 4019 /// 4020 double acosh(double x); 4021 /// 4022 float acoshf(float x); 4023 /// 4024 extern(D) real acoshl(real x) { return acosh(cast(double) x); } 4025 4026 /// 4027 pure double asinh(double x); 4028 /// 4029 pure float asinhf(float x); 4030 /// 4031 extern(D) pure real asinhl(real x) { return asinh(cast(double) x); } 4032 4033 /// 4034 double atanh(double x); 4035 /// 4036 float atanhf(float x); 4037 /// 4038 extern(D) real atanhl(real x) { return atanh(cast(double) x); } 4039 4040 /// 4041 double cosh(double x); 4042 /// 4043 float coshf(float x); 4044 /// 4045 extern(D) real coshl(real x) { return cosh(cast(double) x); } 4046 4047 /// 4048 double sinh(double x); 4049 /// 4050 float sinhf(float x); 4051 /// 4052 extern(D) real sinhl(real x) { return sinh(cast(double) x); } 4053 4054 /// 4055 double tanh(double x); 4056 /// 4057 float tanhf(float x); 4058 /// 4059 extern(D) real tanhl(real x) { return tanh(cast(double) x); } 4060 4061 /// 4062 double exp(double x); 4063 /// 4064 float expf(float x); 4065 /// 4066 extern(D) real expl(real x) { return exp(cast(double) x); } 4067 4068 /// 4069 double exp2(double x); 4070 /// 4071 float exp2f(float x); 4072 /// 4073 extern(D) real exp2l(real x) { return exp2(cast(double) x); } 4074 4075 /// 4076 double expm1(double x); 4077 /// 4078 float expm1f(float x); 4079 /// 4080 extern(D) real expm1l(real x) { return expm1(cast(double) x); } 4081 4082 /// 4083 pure double frexp(double value, int* exp); 4084 /// 4085 pure float frexpf(float value, int* exp); 4086 /// 4087 extern(D) pure real frexpl(real value, int* exp) { return frexp(cast(double) value, exp); } 4088 4089 /// 4090 int ilogb(double x); 4091 /// 4092 int ilogbf(float x); 4093 /// 4094 extern(D) int ilogbl(real x) { return ilogb(cast(double) x); } 4095 4096 /// 4097 double ldexp(double x, int exp); 4098 /// 4099 float ldexpf(float x, int exp); 4100 /// 4101 extern(D) real ldexpl(real x, int exp) { return ldexp(cast(double) x, exp); } 4102 4103 /// 4104 double log(double x); 4105 /// 4106 float logf(float x); 4107 /// 4108 extern(D) real logl(real x) { return log(cast(double) x); } 4109 4110 /// 4111 double log10(double x); 4112 /// 4113 float log10f(float x); 4114 /// 4115 extern(D) real log10l(real x) { return log10(cast(double) x); } 4116 4117 /// 4118 double log1p(double x); 4119 /// 4120 float log1pf(float x); 4121 /// 4122 extern(D) real log1pl(real x) { return log1p(cast(double) x); } 4123 4124 /// 4125 double log2(double x); 4126 /// 4127 float log2f(float x); 4128 /// 4129 extern(D) real log2l(real x) { return log2(cast(double) x); } 4130 4131 /// 4132 double logb(double x); 4133 /// 4134 float logbf(float x); 4135 /// 4136 extern(D) real logbl(real x) { return logb(cast(double) x); } 4137 4138 /// 4139 pure double modf(double value, double* iptr); 4140 /// 4141 pure float modff(float value, float* iptr); 4142 /// 4143 extern(D) pure real modfl(real value, real *iptr) 4144 { 4145 static if (double.sizeof == real.sizeof) 4146 return modf(cast(double) value, cast(double*) iptr); 4147 else 4148 { 4149 double i; 4150 double r = modf(cast(double) value, &i); 4151 *iptr = i; 4152 return r; 4153 } 4154 } 4155 4156 /// 4157 double scalbn(double x, int n); 4158 /// 4159 float scalbnf(float x, int n); 4160 /// 4161 extern(D) real scalbnl(real x, int n) { return scalbln(cast(double) x, n); } 4162 4163 /// 4164 double scalbln(double x, c_long n); 4165 /// 4166 float scalblnf(float x, c_long n); 4167 /// 4168 extern(D) real scalblnl(real x, c_long n) { return scalbln(cast(double) x, n); } 4169 4170 /// 4171 pure double cbrt(double x); 4172 /// 4173 pure float cbrtf(float x); 4174 /// 4175 extern(D) pure real cbrtl(real x) { return cbrt(cast(double) x); } 4176 4177 /// 4178 pure double fabs(double x); 4179 /// 4180 pure float fabsf(float x); 4181 /// 4182 extern(D) pure real fabsl(real x) { return fabs(cast(double) x); } 4183 4184 /// 4185 double hypot(double x, double y); 4186 /// 4187 float hypotf(float x, float y); 4188 /// 4189 extern(D) real hypotl(real x, real y) { return hypot(cast(double) x, cast(double) y); } 4190 4191 /// 4192 double pow(double x, double y); 4193 /// 4194 float powf(float x, float y); 4195 /// 4196 extern(D) real powl(real x, real y) { return pow(cast(double) x, cast(double) y); } 4197 4198 /// 4199 double sqrt(double x); 4200 /// 4201 float sqrtf(float x); 4202 /// 4203 extern(D) real sqrtl(real x) { return sqrt(cast(double) x); } 4204 4205 /// 4206 pure double erf(double x); 4207 /// 4208 pure float erff(float x); 4209 /// 4210 extern(D) pure real erfl(real x) { return erf(cast(double) x); } 4211 4212 /// 4213 double erfc(double x); 4214 /// 4215 float erfcf(float x); 4216 /// 4217 extern(D) real erfcl(real x) { return erfc(cast(double) x); } 4218 4219 /// 4220 double lgamma(double x); 4221 /// 4222 float lgammaf(float x); 4223 /// 4224 extern(D) real lgammal(real x) { return lgamma(cast(double) x); } 4225 4226 /// 4227 double tgamma(double x); 4228 /// 4229 float tgammaf(float x); 4230 /// 4231 extern(D) real tgammal(real x) { return tgamma(cast(double) x); } 4232 4233 /// 4234 pure double ceil(double x); 4235 /// 4236 pure float ceilf(float x); 4237 /// 4238 extern(D) pure real ceill(real x) { return ceil(cast(double) x); } 4239 4240 /// 4241 pure double floor(double x); 4242 /// 4243 pure float floorf(float x); 4244 /// 4245 extern(D) pure real floorl(real x) { return floor(cast(double) x); } 4246 4247 /// 4248 pure double nearbyint(double x); 4249 /// 4250 pure float nearbyintf(float x); 4251 /// 4252 extern(D) pure real nearbyintl(real x) { return nearbyint(cast(double) x); } 4253 4254 /// 4255 pure double rint(double x); 4256 /// 4257 pure float rintf(float x); 4258 /// 4259 extern(D) pure real rintl(real x) { return rint(cast(double) x); } 4260 4261 /// 4262 c_long lrint(double x); 4263 /// 4264 c_long lrintf(float x); 4265 /// 4266 extern(D) c_long lrintl(real x) { return lrint(cast(double) x); } 4267 4268 /// 4269 long llrint(double x); 4270 /// 4271 long llrintf(float x); 4272 /// 4273 extern(D) long llrintl(real x) { return llrint(cast(double) x); } 4274 4275 /// 4276 pure double round(double x); 4277 /// 4278 pure float roundf(float x); 4279 /// 4280 extern(D) pure real roundl(real x) { return round(cast(double) x); } 4281 4282 /// 4283 c_long lround(double x); 4284 /// 4285 c_long lroundf(float x); 4286 /// 4287 extern(D) c_long lroundl(real x) { return lround(cast(double) x); } 4288 4289 /// 4290 long llround(double x); 4291 /// 4292 long llroundf(float x); 4293 /// 4294 extern(D) long llroundl(real x) { return llround(cast(double) x); } 4295 4296 /// 4297 pure double trunc(double x); 4298 /// 4299 pure float truncf(float x); 4300 /// 4301 extern(D) pure real truncl(real x) { return trunc(cast(double) x); } 4302 4303 /// 4304 double fmod(double x, double y); 4305 /// 4306 float fmodf(float x, float y); 4307 /// 4308 extern(D) real fmodl(real x, real y) { return fmod(cast(double) x, cast(double) y); } 4309 4310 /// 4311 double remainder(double x, double y); 4312 /// 4313 float remainderf(float x, float y); 4314 /// 4315 extern(D) real remainderl(real x, real y) { return remainder(cast(double) x, cast(double) y); } 4316 4317 /// 4318 double remquo(double x, double y, int* quo); 4319 /// 4320 float remquof(float x, float y, int* quo); 4321 /// 4322 extern(D) real remquol(real x, real y, int* quo) { return remquo(cast(double) x, cast(double) y, quo); } 4323 4324 /// 4325 pure double copysign(double x, double y); 4326 /// 4327 pure float copysignf(float x, float y); 4328 /// 4329 extern(D) pure real copysignl(real x, real y) { return copysign(cast(double) x, cast(double) y); } 4330 4331 /// 4332 pure double nan(char* tagp); 4333 /// 4334 pure float nanf(char* tagp); 4335 /// 4336 extern(D) pure real nanl(char* tagp) { return nan(tagp); } 4337 4338 /// 4339 double nextafter(double x, double y); 4340 /// 4341 float nextafterf(float x, float y); 4342 /// 4343 extern(D) real nextafterl(real x, real y) { return nextafter(cast(double) x, cast(double) y); } 4344 4345 /// 4346 double nexttoward(double x, real y); 4347 /// 4348 float nexttowardf(float x, real y); 4349 /// 4350 extern(D) real nexttowardl(real x, real y) { return nexttoward(cast(double) x, cast(double) y); } 4351 4352 /// 4353 double fdim(double x, double y); 4354 /// 4355 float fdimf(float x, float y); 4356 /// 4357 extern(D) real fdiml(real x, real y) { return fdim(cast(double) x, cast(double) y); } 4358 4359 /// 4360 pure double fmax(double x, double y); 4361 /// 4362 pure float fmaxf(float x, float y); 4363 /// 4364 extern(D) pure real fmaxl(real x, real y) { return fmax(cast(double) x, cast(double) y); } 4365 4366 /// 4367 pure double fmin(double x, double y); 4368 /// 4369 pure float fminf(float x, float y); 4370 /// 4371 extern(D) pure real fminl(real x, real y) { return fmin(cast(double) x, cast(double) y); } 4372 4373 /// 4374 pure double fma(double x, double y, double z); 4375 /// 4376 pure float fmaf(float x, float y, float z); 4377 /// 4378 extern(D) pure real fmal(real x, real y, real z) { return fma(cast(double) x, cast(double) y, cast(double) z); } 4379 } 4380 else 4381 { 4382 /// 4383 double acos(double x); 4384 /// 4385 float acosf(float x); 4386 /// 4387 real acosl(real x); 4388 4389 /// 4390 double asin(double x); 4391 /// 4392 float asinf(float x); 4393 /// 4394 real asinl(real x); 4395 4396 /// 4397 pure double atan(double x); 4398 /// 4399 pure float atanf(float x); 4400 /// 4401 pure real atanl(real x); 4402 4403 /// 4404 double atan2(double y, double x); 4405 /// 4406 float atan2f(float y, float x); 4407 /// 4408 real atan2l(real y, real x); 4409 4410 /// 4411 pure double cos(double x); 4412 /// 4413 pure float cosf(float x); 4414 /// 4415 pure real cosl(real x); 4416 4417 /// 4418 pure double sin(double x); 4419 /// 4420 pure float sinf(float x); 4421 /// 4422 pure real sinl(real x); 4423 4424 /// 4425 pure double tan(double x); 4426 /// 4427 pure float tanf(float x); 4428 /// 4429 pure real tanl(real x); 4430 4431 /// 4432 double acosh(double x); 4433 /// 4434 float acoshf(float x); 4435 /// 4436 real acoshl(real x); 4437 4438 /// 4439 pure double asinh(double x); 4440 /// 4441 pure float asinhf(float x); 4442 /// 4443 pure real asinhl(real x); 4444 4445 /// 4446 double atanh(double x); 4447 /// 4448 float atanhf(float x); 4449 /// 4450 real atanhl(real x); 4451 4452 /// 4453 double cosh(double x); 4454 /// 4455 float coshf(float x); 4456 /// 4457 real coshl(real x); 4458 4459 /// 4460 double sinh(double x); 4461 /// 4462 float sinhf(float x); 4463 /// 4464 real sinhl(real x); 4465 4466 /// 4467 pure double tanh(double x); 4468 /// 4469 pure float tanhf(float x); 4470 /// 4471 pure real tanhl(real x); 4472 4473 /// 4474 double exp(double x); 4475 /// 4476 float expf(float x); 4477 /// 4478 real expl(real x); 4479 4480 /// 4481 double exp2(double x); 4482 /// 4483 float exp2f(float x); 4484 /// 4485 real exp2l(real x); 4486 4487 /// 4488 double expm1(double x); 4489 /// 4490 float expm1f(float x); 4491 /// 4492 real expm1l(real x); 4493 4494 /// 4495 pure double frexp(double value, int* exp); 4496 /// 4497 pure float frexpf(float value, int* exp); 4498 /// 4499 pure real frexpl(real value, int* exp); 4500 4501 /// 4502 int ilogb(double x); 4503 /// 4504 int ilogbf(float x); 4505 /// 4506 int ilogbl(real x); 4507 4508 /// 4509 double ldexp(double x, int exp); 4510 /// 4511 float ldexpf(float x, int exp); 4512 /// 4513 real ldexpl(real x, int exp); 4514 4515 /// 4516 double log(double x); 4517 /// 4518 float logf(float x); 4519 /// 4520 real logl(real x); 4521 4522 /// 4523 double log10(double x); 4524 /// 4525 float log10f(float x); 4526 /// 4527 real log10l(real x); 4528 4529 /// 4530 double log1p(double x); 4531 /// 4532 float log1pf(float x); 4533 /// 4534 real log1pl(real x); 4535 4536 /// 4537 double log2(double x); 4538 /// 4539 float log2f(float x); 4540 /// 4541 real log2l(real x); 4542 4543 /// 4544 double logb(double x); 4545 /// 4546 float logbf(float x); 4547 /// 4548 real logbl(real x); 4549 4550 /// 4551 pure double modf(double value, double* iptr); 4552 /// 4553 pure float modff(float value, float* iptr); 4554 /// 4555 pure real modfl(real value, real *iptr); 4556 4557 /// 4558 double scalbn(double x, int n); 4559 /// 4560 float scalbnf(float x, int n); 4561 /// 4562 real scalbnl(real x, int n); 4563 4564 /// 4565 double scalbln(double x, c_long n); 4566 /// 4567 float scalblnf(float x, c_long n); 4568 /// 4569 real scalblnl(real x, c_long n); 4570 4571 /// 4572 pure double cbrt(double x); 4573 /// 4574 pure float cbrtf(float x); 4575 /// 4576 pure real cbrtl(real x); 4577 4578 /// 4579 pure double fabs(double x); 4580 version (CRuntime_Microsoft) 4581 { 4582 } 4583 else 4584 { 4585 /// 4586 pure float fabsf(float x); 4587 /// 4588 pure real fabsl(real x); 4589 } 4590 4591 /// 4592 double hypot(double x, double y); 4593 /// 4594 float hypotf(float x, float y); 4595 /// 4596 real hypotl(real x, real y); 4597 4598 /// 4599 double pow(double x, double y); 4600 /// 4601 float powf(float x, float y); 4602 /// 4603 real powl(real x, real y); 4604 4605 /// 4606 double sqrt(double x); 4607 /// 4608 float sqrtf(float x); 4609 /// 4610 real sqrtl(real x); 4611 4612 /// 4613 pure double erf(double x); 4614 /// 4615 pure float erff(float x); 4616 /// 4617 pure real erfl(real x); 4618 4619 /// 4620 double erfc(double x); 4621 /// 4622 float erfcf(float x); 4623 /// 4624 real erfcl(real x); 4625 4626 /// 4627 double lgamma(double x); 4628 /// 4629 float lgammaf(float x); 4630 /// 4631 real lgammal(real x); 4632 4633 /// 4634 double tgamma(double x); 4635 /// 4636 float tgammaf(float x); 4637 /// 4638 real tgammal(real x); 4639 4640 /// 4641 pure double ceil(double x); 4642 /// 4643 pure float ceilf(float x); 4644 /// 4645 pure real ceill(real x); 4646 4647 /// 4648 pure double floor(double x); 4649 /// 4650 pure float floorf(float x); 4651 /// 4652 pure real floorl(real x); 4653 4654 /// 4655 pure double nearbyint(double x); 4656 /// 4657 pure float nearbyintf(float x); 4658 /// 4659 pure real nearbyintl(real x); 4660 4661 /// 4662 pure double rint(double x); 4663 /// 4664 pure float rintf(float x); 4665 /// 4666 pure real rintl(real x); 4667 4668 /// 4669 c_long lrint(double x); 4670 /// 4671 c_long lrintf(float x); 4672 /// 4673 c_long lrintl(real x); 4674 4675 /// 4676 long llrint(double x); 4677 /// 4678 long llrintf(float x); 4679 /// 4680 long llrintl(real x); 4681 4682 /// 4683 pure double round(double x); 4684 /// 4685 pure float roundf(float x); 4686 /// 4687 pure real roundl(real x); 4688 4689 /// 4690 c_long lround(double x); 4691 /// 4692 c_long lroundf(float x); 4693 /// 4694 c_long lroundl(real x); 4695 4696 /// 4697 long llround(double x); 4698 /// 4699 long llroundf(float x); 4700 /// 4701 long llroundl(real x); 4702 4703 /// 4704 pure double trunc(double x); 4705 /// 4706 pure float truncf(float x); 4707 /// 4708 pure real truncl(real x); 4709 4710 /// 4711 double fmod(double x, double y); 4712 /// 4713 float fmodf(float x, float y); 4714 /// 4715 real fmodl(real x, real y); 4716 4717 /// 4718 double remainder(double x, double y); 4719 /// 4720 float remainderf(float x, float y); 4721 /// 4722 real remainderl(real x, real y); 4723 4724 /// 4725 double remquo(double x, double y, int* quo); 4726 /// 4727 float remquof(float x, float y, int* quo); 4728 /// 4729 real remquol(real x, real y, int* quo); 4730 4731 /// 4732 pure double copysign(double x, double y); 4733 /// 4734 pure float copysignf(float x, float y); 4735 /// 4736 pure real copysignl(real x, real y); 4737 4738 /// 4739 pure double nan(char* tagp); 4740 /// 4741 pure float nanf(char* tagp); 4742 /// 4743 pure real nanl(char* tagp); 4744 4745 /// 4746 double nextafter(double x, double y); 4747 /// 4748 float nextafterf(float x, float y); 4749 /// 4750 real nextafterl(real x, real y); 4751 4752 /// 4753 double nexttoward(double x, real y); 4754 /// 4755 float nexttowardf(float x, real y); 4756 /// 4757 real nexttowardl(real x, real y); 4758 4759 /// 4760 double fdim(double x, double y); 4761 /// 4762 float fdimf(float x, float y); 4763 /// 4764 real fdiml(real x, real y); 4765 4766 /// 4767 pure double fmax(double x, double y); 4768 /// 4769 pure float fmaxf(float x, float y); 4770 /// 4771 pure real fmaxl(real x, real y); 4772 4773 /// 4774 pure double fmin(double x, double y); 4775 /// 4776 pure float fminf(float x, float y); 4777 /// 4778 pure real fminl(real x, real y); 4779 4780 /// 4781 pure double fma(double x, double y, double z); 4782 /// 4783 pure float fmaf(float x, float y, float z); 4784 /// 4785 pure real fmal(real x, real y, real z); 4786 }