1 /** 2 * 80-bit floating point value implementation if the C/D compiler does not support them natively. 3 * 4 * Copyright (C) 1999-2020 by The D Language Foundation, All Rights Reserved 5 * All Rights Reserved, written by Rainer Schuetze 6 * http://www.digitalmars.com 7 * Distributed under the Boost Software License, Version 1.0. 8 * (See accompanying file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt) 9 * https://github.com/dlang/dmd/blob/master/src/root/longdouble.d 10 */ 11 12 module dmd.root.longdouble; 13 14 static if (real.sizeof > 8) 15 alias longdouble = real; 16 else 17 alias longdouble = longdouble_soft; 18 19 // longdouble_soft needed when building the backend with 20 // Visual C or the frontend with LDC on Windows 21 version(CRuntime_Microsoft): 22 extern(C++): 23 nothrow: 24 @nogc: 25 26 version(D_InlineAsm_X86_64) 27 version = AsmX86; 28 else version(D_InlineAsm_X86) 29 version = AsmX86; 30 else 31 static assert(false, "longdouble_soft not supported on this platform"); 32 33 bool initFPU() 34 { 35 version(D_InlineAsm_X86_64) 36 { 37 // set precision to 64-bit mantissa and rounding control to nearest 38 asm nothrow @nogc @trusted 39 { 40 push RAX; // add space on stack 41 fstcw word ptr [RSP]; 42 movzx EAX,word ptr [RSP]; // also return old CW in EAX 43 and EAX, ~0xF00; // mask for PC and RC 44 or EAX, 0x300; 45 mov dword ptr [RSP],EAX; 46 fldcw word ptr [RSP]; 47 pop RAX; 48 } 49 } 50 else version(D_InlineAsm_X86) 51 { 52 // set precision to 64-bit mantissa and rounding control to nearest 53 asm nothrow @nogc @trusted 54 { 55 push EAX; // add space on stack 56 fstcw word ptr [ESP]; 57 movzx EAX,word ptr [ESP]; // also return old CW in EAX 58 and EAX, ~0xF00; // mask for PC and RC 59 or EAX, 0x300; 60 mov dword ptr [ESP],EAX; 61 fldcw word ptr [ESP]; 62 pop EAX; 63 } 64 } 65 66 return true; 67 } 68 69 version(unittest) version(CRuntime_Microsoft) 70 extern(D) shared static this() 71 { 72 initFPU(); // otherwise not guaranteed to be run before pure unittest below 73 } 74 75 void ld_clearfpu() 76 { 77 version(AsmX86) 78 { 79 asm nothrow @nogc @trusted 80 { 81 fclex; 82 } 83 } 84 } 85 86 pure: 87 @trusted: // LDC: LLVM __asm is @system AND requires taking the address of variables 88 89 struct longdouble_soft 90 { 91 nothrow @nogc pure: 92 // DMD's x87 `real` on Windows is packed (alignof = 2 -> sizeof = 10). 93 align(2) ulong mantissa = 0xC000000000000000UL; // default to qnan 94 ushort exp_sign = 0x7fff; // sign is highest bit 95 96 this(ulong m, ushort es) { mantissa = m; exp_sign = es; } 97 this(longdouble_soft ld) { mantissa = ld.mantissa; exp_sign = ld.exp_sign; } 98 this(int i) { ld_set(&this, i); } 99 this(uint i) { ld_set(&this, i); } 100 this(long i) { ld_setll(&this, i); } 101 this(ulong i) { ld_setull(&this, i); } 102 this(float f) { ld_set(&this, f); } 103 this(double d) 104 { 105 // allow zero initialization at compile time 106 if (__ctfe && d == 0) 107 { 108 mantissa = 0; 109 exp_sign = 0; 110 } 111 else 112 ld_set(&this, d); 113 } 114 this(real r) 115 { 116 static if (real.sizeof > 8) 117 *cast(real*)&this = r; 118 else 119 this(cast(double)r); 120 } 121 122 ushort exponent() const { return exp_sign & 0x7fff; } 123 bool sign() const { return (exp_sign & 0x8000) != 0; } 124 125 extern(D) 126 { 127 ref longdouble_soft opAssign(longdouble_soft ld) return { mantissa = ld.mantissa; exp_sign = ld.exp_sign; return this; } 128 ref longdouble_soft opAssign(T)(T rhs) { this = longdouble_soft(rhs); return this; } 129 130 longdouble_soft opUnary(string op)() const 131 { 132 static if (op == "-") return longdouble_soft(mantissa, exp_sign ^ 0x8000); 133 else static assert(false, "Operator `"~op~"` is not implemented"); 134 } 135 136 bool opEquals(T)(T rhs) const { return this.ld_cmpe(longdouble_soft(rhs)); } 137 int opCmp(T)(T rhs) const { return this.ld_cmp(longdouble_soft(rhs)); } 138 139 longdouble_soft opBinary(string op, T)(T rhs) const 140 { 141 static if (op == "+") return this.ld_add(longdouble_soft(rhs)); 142 else static if (op == "-") return this.ld_sub(longdouble_soft(rhs)); 143 else static if (op == "*") return this.ld_mul(longdouble_soft(rhs)); 144 else static if (op == "/") return this.ld_div(longdouble_soft(rhs)); 145 else static if (op == "%") return this.ld_mod(longdouble_soft(rhs)); 146 else static assert(false, "Operator `"~op~"` is not implemented"); 147 } 148 149 longdouble_soft opBinaryRight(string op, T)(T rhs) const 150 { 151 static if (op == "+") return longdouble_soft(rhs).ld_add(this); 152 else static if (op == "-") return longdouble_soft(rhs).ld_sub(this); 153 else static if (op == "*") return longdouble_soft(rhs).ld_mul(this); 154 else static if (op == "%") return longdouble_soft(rhs).ld_mod(this); 155 else static assert(false, "Operator `"~op~"` is not implemented"); 156 } 157 158 ref longdouble_soft opOpAssign(string op)(longdouble_soft rhs) 159 { 160 mixin("this = this " ~ op ~ " rhs;"); 161 return this; 162 } 163 164 T opCast(T)() const @trusted 165 { 166 static if (is(T == bool)) return mantissa != 0 || (exp_sign & 0x7fff) != 0; 167 else static if (is(T == byte)) return cast(T)ld_read(&this); 168 else static if (is(T == ubyte)) return cast(T)ld_read(&this); 169 else static if (is(T == short)) return cast(T)ld_read(&this); 170 else static if (is(T == ushort)) return cast(T)ld_read(&this); 171 else static if (is(T == int)) return cast(T)ld_read(&this); 172 else static if (is(T == uint)) return cast(T)ld_read(&this); 173 else static if (is(T == float)) return cast(T)ld_read(&this); 174 else static if (is(T == double)) return cast(T)ld_read(&this); 175 else static if (is(T == long)) return ld_readll(&this); 176 else static if (is(T == ulong)) return ld_readull(&this); 177 else static if (is(T == real)) 178 { 179 // convert to front end real if built with dmd 180 if (real.sizeof > 8) 181 return *cast(real*)&this; 182 else 183 return ld_read(&this); 184 } 185 else static assert(false, "usupported type"); 186 } 187 } 188 189 // a qnan 190 static longdouble_soft nan() { return longdouble_soft(0xC000000000000000UL, 0x7fff); } 191 static longdouble_soft infinity() { return longdouble_soft(0x8000000000000000UL, 0x7fff); } 192 static longdouble_soft zero() { return longdouble_soft(0, 0); } 193 static longdouble_soft max() { return longdouble_soft(0xffffffffffffffffUL, 0x7ffe); } 194 static longdouble_soft min_normal() { return longdouble_soft(0x8000000000000000UL, 1); } 195 static longdouble_soft epsilon() { return longdouble_soft(0x8000000000000000UL, 0x3fff - 63); } 196 197 static uint dig() { return 18; } 198 static uint mant_dig() { return 64; } 199 static uint max_exp() { return 16384; } 200 static uint min_exp() { return -16381; } 201 static uint max_10_exp() { return 4932; } 202 static uint min_10_exp() { return -4932; } 203 } 204 205 static assert(longdouble_soft.alignof == longdouble.alignof); 206 static assert(longdouble_soft.sizeof == longdouble.sizeof); 207 208 version(LDC) 209 { 210 import ldc.llvmasm; 211 212 extern(D): 213 private: 214 string fld_arg (string arg)() { return `__asm("fldt $0", "*m,~{st}", &` ~ arg ~ `);`; } 215 string fstp_arg (string arg)() { return `__asm("fstpt $0", "=*m,~{st}", &` ~ arg ~ `);`; } 216 string fld_parg (string arg)() { return `__asm("fldt $0", "*m,~{st}", ` ~ arg ~ `);`; } 217 string fstp_parg(string arg)() { return `__asm("fstpt $0", "=*m,~{st}", ` ~ arg ~ `);`; } 218 } 219 else version(D_InlineAsm_X86_64) 220 { 221 // longdouble_soft passed by reference 222 extern(D): 223 private: 224 string fld_arg(string arg)() 225 { 226 return "asm nothrow @nogc pure @trusted { mov RAX, " ~ arg ~ "; fld real ptr [RAX]; }"; 227 } 228 string fstp_arg(string arg)() 229 { 230 return "asm nothrow @nogc pure @trusted { mov RAX, " ~ arg ~ "; fstp real ptr [RAX]; }"; 231 } 232 alias fld_parg = fld_arg; 233 alias fstp_parg = fstp_arg; 234 } 235 else version(D_InlineAsm_X86) 236 { 237 // longdouble_soft passed by value 238 extern(D): 239 private: 240 string fld_arg(string arg)() 241 { 242 return "asm nothrow @nogc pure @trusted { lea EAX, " ~ arg ~ "; fld real ptr [EAX]; }"; 243 } 244 string fstp_arg(string arg)() 245 { 246 return "asm nothrow @nogc pure @trusted { lea EAX, " ~ arg ~ "; fstp real ptr [EAX]; }"; 247 } 248 string fld_parg(string arg)() 249 { 250 return "asm nothrow @nogc pure @trusted { mov EAX, " ~ arg ~ "; fld real ptr [EAX]; }"; 251 } 252 string fstp_parg(string arg)() 253 { 254 return "asm nothrow @nogc pure @trusted { mov EAX, " ~ arg ~ "; fstp real ptr [EAX]; }"; 255 } 256 } 257 258 double ld_read(const longdouble_soft* pthis) 259 { 260 double res; 261 version(AsmX86) 262 { 263 mixin(fld_parg!("pthis")); 264 asm nothrow @nogc pure @trusted 265 { 266 fstp res; 267 } 268 } 269 return res; 270 } 271 272 long ld_readll(const longdouble_soft* pthis) 273 { 274 return ld_readull(pthis); 275 } 276 277 ulong ld_readull(const longdouble_soft* pthis) 278 { 279 // somehow the FPU does not respect the CHOP mode of the rounding control 280 // in 64-bit mode 281 // so we roll our own conversion (it also allows the usual C wrap-around 282 // instead of the "invalid value" created by the FPU) 283 int expo = pthis.exponent - 0x3fff; 284 ulong u; 285 if(expo < 0 || expo > 127) 286 return 0; 287 if(expo < 64) 288 u = pthis.mantissa >> (63 - expo); 289 else 290 u = pthis.mantissa << (expo - 63); 291 if(pthis.sign) 292 u = ~u + 1; 293 return u; 294 } 295 296 int ld_statusfpu() 297 { 298 int res = 0; 299 version(AsmX86) 300 { 301 asm nothrow @nogc pure @trusted 302 { 303 fstsw word ptr [res]; 304 } 305 } 306 return res; 307 } 308 309 void ld_set(longdouble_soft* pthis, double d) 310 { 311 version(AsmX86) 312 { 313 asm nothrow @nogc pure @trusted 314 { 315 fld d; 316 } 317 mixin(fstp_parg!("pthis")); 318 } 319 } 320 321 void ld_setll(longdouble_soft* pthis, long d) 322 { 323 version(AsmX86) 324 { 325 asm nothrow @nogc pure @trusted 326 { 327 fild qword ptr d; 328 } 329 mixin(fstp_parg!("pthis")); 330 } 331 } 332 333 void ld_setull(longdouble_soft* pthis, ulong d) 334 { 335 d ^= (1L << 63); 336 version(AsmX86) 337 { 338 auto pTwoPow63 = &twoPow63; 339 mixin(fld_parg!("pTwoPow63")); 340 asm nothrow @nogc pure @trusted 341 { 342 fild qword ptr d; 343 faddp; 344 } 345 mixin(fstp_parg!("pthis")); 346 } 347 } 348 349 // using an argument as result to avoid RVO, see https://issues.dlang.org/show_bug.cgi?id=18758 350 longdouble_soft ldexpl(longdouble_soft ld, int exp) 351 { 352 version(AsmX86) 353 { 354 asm nothrow @nogc pure @trusted 355 { 356 fild dword ptr exp; 357 } 358 mixin(fld_arg!("ld")); 359 asm nothrow @nogc pure @trusted 360 { 361 fscale; // ST(0) = ST(0) * (2**ST(1)) 362 fstp ST(1); 363 } 364 mixin(fstp_arg!("ld")); 365 } 366 return ld; 367 } 368 369 /////////////////////////////////////////////////////////////////////// 370 longdouble_soft ld_add(longdouble_soft ld1, longdouble_soft ld2) 371 { 372 version(AsmX86) 373 { 374 mixin(fld_arg!("ld1")); 375 mixin(fld_arg!("ld2")); 376 asm nothrow @nogc pure @trusted 377 { 378 fadd; 379 } 380 mixin(fstp_arg!("ld1")); 381 } 382 return ld1; 383 } 384 385 longdouble_soft ld_sub(longdouble_soft ld1, longdouble_soft ld2) 386 { 387 version(AsmX86) 388 { 389 mixin(fld_arg!("ld1")); 390 mixin(fld_arg!("ld2")); 391 asm nothrow @nogc pure @trusted 392 { 393 fsub; 394 } 395 mixin(fstp_arg!("ld1")); 396 } 397 return ld1; 398 } 399 400 longdouble_soft ld_mul(longdouble_soft ld1, longdouble_soft ld2) 401 { 402 version(AsmX86) 403 { 404 mixin(fld_arg!("ld1")); 405 mixin(fld_arg!("ld2")); 406 asm nothrow @nogc pure @trusted 407 { 408 fmul; 409 } 410 mixin(fstp_arg!("ld1")); 411 } 412 return ld1; 413 } 414 415 longdouble_soft ld_div(longdouble_soft ld1, longdouble_soft ld2) 416 { 417 version(AsmX86) 418 { 419 mixin(fld_arg!("ld1")); 420 mixin(fld_arg!("ld2")); 421 asm nothrow @nogc pure @trusted 422 { 423 fdiv; 424 } 425 mixin(fstp_arg!("ld1")); 426 } 427 return ld1; 428 } 429 430 bool ld_cmpb(longdouble_soft x, longdouble_soft y) 431 { 432 short sw; 433 bool res; 434 version(AsmX86) 435 { 436 mixin(fld_arg!("y")); 437 mixin(fld_arg!("x")); 438 asm nothrow @nogc pure @trusted 439 { 440 fucomip ST(1); 441 setb AL; 442 setnp AH; 443 and AL,AH; 444 mov res,AL; 445 fstp ST(0); 446 } 447 } 448 return res; 449 } 450 451 bool ld_cmpbe(longdouble_soft x, longdouble_soft y) 452 { 453 short sw; 454 bool res; 455 version(AsmX86) 456 { 457 mixin(fld_arg!("y")); 458 mixin(fld_arg!("x")); 459 asm nothrow @nogc pure @trusted 460 { 461 fucomip ST(1); 462 setbe AL; 463 setnp AH; 464 and AL,AH; 465 mov res,AL; 466 fstp ST(0); 467 } 468 } 469 return res; 470 } 471 472 bool ld_cmpa(longdouble_soft x, longdouble_soft y) 473 { 474 short sw; 475 bool res; 476 version(AsmX86) 477 { 478 mixin(fld_arg!("y")); 479 mixin(fld_arg!("x")); 480 asm nothrow @nogc pure @trusted 481 { 482 fucomip ST(1); 483 seta AL; 484 setnp AH; 485 and AL,AH; 486 mov res,AL; 487 fstp ST(0); 488 } 489 } 490 return res; 491 } 492 493 bool ld_cmpae(longdouble_soft x, longdouble_soft y) 494 { 495 short sw; 496 bool res; 497 version(AsmX86) 498 { 499 mixin(fld_arg!("y")); 500 mixin(fld_arg!("x")); 501 asm nothrow @nogc pure @trusted 502 { 503 fucomip ST(1); 504 setae AL; 505 setnp AH; 506 and AL,AH; 507 mov res,AL; 508 fstp ST(0); 509 } 510 } 511 return res; 512 } 513 514 bool ld_cmpe(longdouble_soft x, longdouble_soft y) 515 { 516 short sw; 517 bool res; 518 version(AsmX86) 519 { 520 mixin(fld_arg!("y")); 521 mixin(fld_arg!("x")); 522 asm nothrow @nogc pure @trusted 523 { 524 fucomip ST(1); 525 sete AL; 526 setnp AH; 527 and AL,AH; 528 mov res,AL; 529 fstp ST(0); 530 } 531 } 532 return res; 533 } 534 535 bool ld_cmpne(longdouble_soft x, longdouble_soft y) 536 { 537 short sw; 538 bool res; 539 version(AsmX86) 540 { 541 mixin(fld_arg!("y")); 542 mixin(fld_arg!("x")); 543 asm nothrow @nogc pure @trusted 544 { 545 fucomip ST(1); 546 setne AL; 547 setp AH; 548 or AL,AH; 549 mov res,AL; 550 fstp ST(0); 551 } 552 } 553 return res; 554 } 555 556 int ld_cmp(longdouble_soft x, longdouble_soft y) 557 { 558 // return -1 if x < y, 0 if x == y or unordered, 1 if x > y 559 short sw; 560 int res; 561 version(AsmX86) 562 { 563 mixin(fld_arg!("y")); 564 mixin(fld_arg!("x")); 565 asm nothrow @nogc pure @trusted 566 { 567 fucomip ST(1); 568 seta AL; 569 setb AH; 570 setp DL; 571 or AL, DL; 572 or AH, DL; 573 sub AL, AH; 574 movsx EAX, AL; 575 fstp ST(0); 576 mov res, EAX; 577 } 578 } 579 } 580 581 582 int _isnan(longdouble_soft ld) 583 { 584 return (ld.exponent == 0x7fff && ld.mantissa != 0 && ld.mantissa != (1L << 63)); // exclude pseudo-infinity and infinity, but not FP Indefinite 585 } 586 587 longdouble_soft fabsl(longdouble_soft ld) 588 { 589 ld.exp_sign = ld.exponent; 590 return ld; 591 } 592 593 longdouble_soft sqrtl(longdouble_soft ld) 594 { 595 version(AsmX86) 596 { 597 mixin(fld_arg!("ld")); 598 asm nothrow @nogc pure @trusted 599 { 600 fsqrt; 601 } 602 mixin(fstp_arg!("ld")); 603 } 604 return ld; 605 } 606 607 longdouble_soft sqrt(longdouble_soft ld) { return sqrtl(ld); } 608 609 longdouble_soft sinl (longdouble_soft ld) 610 { 611 version(AsmX86) 612 { 613 mixin(fld_arg!("ld")); 614 asm nothrow @nogc pure @trusted 615 { 616 fsin; // exact for |x|<=PI/4 617 } 618 mixin(fstp_arg!("ld")); 619 } 620 return ld; 621 } 622 longdouble_soft cosl (longdouble_soft ld) 623 { 624 version(AsmX86) 625 { 626 mixin(fld_arg!("ld")); 627 asm nothrow @nogc pure @trusted 628 { 629 fcos; // exact for |x|<=PI/4 630 } 631 mixin(fstp_arg!("ld")); 632 } 633 return ld; 634 } 635 longdouble_soft tanl (longdouble_soft ld) 636 { 637 version(AsmX86) 638 { 639 mixin(fld_arg!("ld")); 640 asm nothrow @nogc pure @trusted 641 { 642 fptan; 643 fstp ST(0); // always 1 644 } 645 mixin(fstp_arg!("ld")); 646 } 647 return ld; 648 } 649 650 longdouble_soft fmodl(longdouble_soft x, longdouble_soft y) 651 { 652 return ld_mod(x, y); 653 } 654 655 longdouble_soft ld_mod(longdouble_soft x, longdouble_soft y) 656 { 657 short sw; 658 version(AsmX86) 659 { 660 mixin(fld_arg!("y")); 661 mixin(fld_arg!("x")); 662 asm nothrow @nogc pure @trusted 663 { 664 FM1: // We don't use fprem1 because for some inexplicable 665 // reason we get -5 when we do _modulo(15, 10) 666 fprem; // ST = ST % ST1 667 fstsw word ptr sw; 668 fwait; 669 mov AH,byte ptr sw+1; // get msb of status word in AH 670 sahf; // transfer to flags 671 jp FM1; // continue till ST < ST1 672 fstp ST(1); // leave remainder on stack 673 } 674 mixin(fstp_arg!("x")); 675 } 676 return x; 677 } 678 679 ////////////////////////////////////////////////////////////// 680 681 @safe: 682 683 __gshared const 684 { 685 longdouble_soft ld_qnan = longdouble_soft(0xC000000000000000UL, 0x7fff); 686 longdouble_soft ld_inf = longdouble_soft(0x8000000000000000UL, 0x7fff); 687 688 longdouble_soft ld_zero = longdouble_soft(0, 0); 689 longdouble_soft ld_one = longdouble_soft(0x8000000000000000UL, 0x3fff); 690 longdouble_soft ld_pi = longdouble_soft(0xc90fdaa22168c235UL, 0x4000); 691 longdouble_soft ld_log2t = longdouble_soft(0xd49a784bcd1b8afeUL, 0x4000); 692 longdouble_soft ld_log2e = longdouble_soft(0xb8aa3b295c17f0bcUL, 0x3fff); 693 longdouble_soft ld_log2 = longdouble_soft(0x9a209a84fbcff799UL, 0x3ffd); 694 longdouble_soft ld_ln2 = longdouble_soft(0xb17217f7d1cf79acUL, 0x3ffe); 695 696 longdouble_soft ld_pi2 = longdouble_soft(0xc90fdaa22168c235UL, 0x4001); 697 longdouble_soft ld_piOver2 = longdouble_soft(0xc90fdaa22168c235UL, 0x3fff); 698 longdouble_soft ld_piOver4 = longdouble_soft(0xc90fdaa22168c235UL, 0x3ffe); 699 700 longdouble_soft twoPow63 = longdouble_soft(1UL << 63, 0x3fff + 63); 701 } 702 703 ////////////////////////////////////////////////////////////// 704 705 enum LD_TYPE_OTHER = 0; 706 enum LD_TYPE_ZERO = 1; 707 enum LD_TYPE_INFINITE = 2; 708 enum LD_TYPE_SNAN = 3; 709 enum LD_TYPE_QNAN = 4; 710 711 int ld_type(longdouble_soft x) 712 { 713 // see https://en.wikipedia.org/wiki/Extended_precision 714 if(x.exponent == 0) 715 return x.mantissa == 0 ? LD_TYPE_ZERO : LD_TYPE_OTHER; // dnormal if not zero 716 if(x.exponent != 0x7fff) 717 return LD_TYPE_OTHER; // normal or denormal 718 uint upper2 = x.mantissa >> 62; 719 ulong lower62 = x.mantissa & ((1L << 62) - 1); 720 if(upper2 == 0 && lower62 == 0) 721 return LD_TYPE_INFINITE; // pseudo-infinity 722 if(upper2 == 2 && lower62 == 0) 723 return LD_TYPE_INFINITE; // infinity 724 if(upper2 == 2 && lower62 != 0) 725 return LD_TYPE_SNAN; 726 return LD_TYPE_QNAN; // qnan, indefinite, pseudo-nan 727 } 728 729 // consider sprintf pure 730 private extern(C) int sprintf(scope char* s, scope const char* format, ...) pure @nogc nothrow; 731 732 size_t ld_sprint(char* str, int fmt, longdouble_soft x) @system 733 { 734 // ensure dmc compatible strings for nan and inf 735 switch(ld_type(x)) 736 { 737 case LD_TYPE_QNAN: 738 case LD_TYPE_SNAN: 739 return sprintf(str, "nan"); 740 case LD_TYPE_INFINITE: 741 return sprintf(str, x.sign ? "-inf" : "inf"); 742 default: 743 break; 744 } 745 746 // fmt is 'a','A','f' or 'g' 747 if(fmt != 'a' && fmt != 'A') 748 { 749 char[3] format = ['%', cast(char)fmt, 0]; 750 return sprintf(str, format.ptr, ld_read(&x)); 751 } 752 753 ushort exp = x.exponent; 754 ulong mantissa = x.mantissa; 755 756 if(ld_type(x) == LD_TYPE_ZERO) 757 return sprintf(str, fmt == 'a' ? "0x0.0L" : "0X0.0L"); 758 759 size_t len = 0; 760 if(x.sign) 761 str[len++] = '-'; 762 str[len++] = '0'; 763 str[len++] = cast(char)('X' + fmt - 'A'); 764 str[len++] = mantissa & (1L << 63) ? '1' : '0'; 765 str[len++] = '.'; 766 mantissa = mantissa << 1; 767 while(mantissa) 768 { 769 int dig = (mantissa >> 60) & 0xf; 770 dig += dig < 10 ? '0' : fmt - 10; 771 str[len++] = cast(char)dig; 772 mantissa = mantissa << 4; 773 } 774 str[len++] = cast(char)('P' + fmt - 'A'); 775 if(exp < 0x3fff) 776 { 777 str[len++] = '-'; 778 exp = cast(ushort)(0x3fff - exp); 779 } 780 else 781 { 782 str[len++] = '+'; 783 exp = cast(ushort)(exp - 0x3fff); 784 } 785 size_t exppos = len; 786 for(int i = 12; i >= 0; i -= 4) 787 { 788 int dig = (exp >> i) & 0xf; 789 if(dig != 0 || len > exppos || i == 0) 790 str[len++] = cast(char)(dig + (dig < 10 ? '0' : fmt - 10)); 791 } 792 str[len] = 0; 793 return len; 794 } 795 796 ////////////////////////////////////////////////////////////// 797 798 @system unittest 799 { 800 import core.stdc..string; 801 import core.stdc.stdio; 802 803 char[32] buffer; 804 ld_sprint(buffer.ptr, 'a', ld_pi); 805 assert(strcmp(buffer.ptr, "0x1.921fb54442d1846ap+1") == 0); 806 807 ld_sprint(buffer.ptr, 'g', longdouble_soft(2.0)); 808 assert(strcmp(buffer.ptr, "2.00000") == 0); 809 810 ld_sprint(buffer.ptr, 'g', longdouble_soft(1234567.89)); 811 assert(strcmp(buffer.ptr, "1.23457e+06") == 0); 812 813 ld_sprint(buffer.ptr, 'g', ld_inf); 814 assert(strcmp(buffer.ptr, "inf") == 0); 815 816 ld_sprint(buffer.ptr, 'g', ld_qnan); 817 assert(strcmp(buffer.ptr, "nan") == 0); 818 819 longdouble_soft ldb = longdouble_soft(0.4); 820 long b = cast(long)ldb; 821 assert(b == 0); 822 823 b = cast(long)longdouble_soft(0.9); 824 assert(b == 0); 825 826 long x = 0x12345678abcdef78L; 827 longdouble_soft ldx = longdouble_soft(x); 828 assert(ldx > ld_zero); 829 long y = cast(long)ldx; 830 assert(x == y); 831 832 x = -0x12345678abcdef78L; 833 ldx = longdouble_soft(x); 834 assert(ldx < ld_zero); 835 y = cast(long)ldx; 836 assert(x == y); 837 838 ulong u = 0x12345678abcdef78L; 839 longdouble_soft ldu = longdouble_soft(u); 840 assert(ldu > ld_zero); 841 ulong v = cast(ulong)ldu; 842 assert(u == v); 843 844 u = 0xf234567812345678UL; 845 ldu = longdouble_soft(u); 846 assert(ldu > ld_zero); 847 v = cast(ulong)ldu; 848 assert(u == v); 849 850 u = 0xf2345678; 851 ldu = longdouble_soft(u); 852 ldu = ldu * ldu; 853 ldu = sqrt(ldu); 854 v = cast(ulong)ldu; 855 assert(u == v); 856 857 u = 0x123456789A; 858 ldu = longdouble_soft(u); 859 ldu = ldu * longdouble_soft(1L << 23); 860 v = cast(ulong)ldu; 861 u = u * (1L << 23); 862 assert(u == v); 863 }