0.000 000 000 000 000 000 176 182 853 15 Converted to 32 Bit Single Precision IEEE 754 Binary Floating Point Representation Standard

Convert decimal 0.000 000 000 000 000 000 176 182 853 15(10) to 32 bit single precision IEEE 754 binary floating point representation standard (1 bit for sign, 8 bits for exponent, 23 bits for mantissa)

What are the steps to convert decimal number
0.000 000 000 000 000 000 176 182 853 15(10) to 32 bit single precision IEEE 754 binary floating point representation (1 bit for sign, 8 bits for exponent, 23 bits for mantissa)

1. First, convert to binary (in base 2) the integer part: 0.
Divide the number repeatedly by 2.

Keep track of each remainder.

We stop when we get a quotient that is equal to zero.


  • division = quotient + remainder;
  • 0 ÷ 2 = 0 + 0;

2. Construct the base 2 representation of the integer part of the number.

Take all the remainders starting from the bottom of the list constructed above.

0(10) =

0(2)


3. Convert to binary (base 2) the fractional part: 0.000 000 000 000 000 000 176 182 853 15.

Multiply it repeatedly by 2.

Keep track of each integer part of the results.

Stop when we get a fractional part that is equal to zero.


  • #) multiplying = integer + fractional part;
  • 1) 0.000 000 000 000 000 000 176 182 853 15 × 2 = 0 + 0.000 000 000 000 000 000 352 365 706 3;
  • 2) 0.000 000 000 000 000 000 352 365 706 3 × 2 = 0 + 0.000 000 000 000 000 000 704 731 412 6;
  • 3) 0.000 000 000 000 000 000 704 731 412 6 × 2 = 0 + 0.000 000 000 000 000 001 409 462 825 2;
  • 4) 0.000 000 000 000 000 001 409 462 825 2 × 2 = 0 + 0.000 000 000 000 000 002 818 925 650 4;
  • 5) 0.000 000 000 000 000 002 818 925 650 4 × 2 = 0 + 0.000 000 000 000 000 005 637 851 300 8;
  • 6) 0.000 000 000 000 000 005 637 851 300 8 × 2 = 0 + 0.000 000 000 000 000 011 275 702 601 6;
  • 7) 0.000 000 000 000 000 011 275 702 601 6 × 2 = 0 + 0.000 000 000 000 000 022 551 405 203 2;
  • 8) 0.000 000 000 000 000 022 551 405 203 2 × 2 = 0 + 0.000 000 000 000 000 045 102 810 406 4;
  • 9) 0.000 000 000 000 000 045 102 810 406 4 × 2 = 0 + 0.000 000 000 000 000 090 205 620 812 8;
  • 10) 0.000 000 000 000 000 090 205 620 812 8 × 2 = 0 + 0.000 000 000 000 000 180 411 241 625 6;
  • 11) 0.000 000 000 000 000 180 411 241 625 6 × 2 = 0 + 0.000 000 000 000 000 360 822 483 251 2;
  • 12) 0.000 000 000 000 000 360 822 483 251 2 × 2 = 0 + 0.000 000 000 000 000 721 644 966 502 4;
  • 13) 0.000 000 000 000 000 721 644 966 502 4 × 2 = 0 + 0.000 000 000 000 001 443 289 933 004 8;
  • 14) 0.000 000 000 000 001 443 289 933 004 8 × 2 = 0 + 0.000 000 000 000 002 886 579 866 009 6;
  • 15) 0.000 000 000 000 002 886 579 866 009 6 × 2 = 0 + 0.000 000 000 000 005 773 159 732 019 2;
  • 16) 0.000 000 000 000 005 773 159 732 019 2 × 2 = 0 + 0.000 000 000 000 011 546 319 464 038 4;
  • 17) 0.000 000 000 000 011 546 319 464 038 4 × 2 = 0 + 0.000 000 000 000 023 092 638 928 076 8;
  • 18) 0.000 000 000 000 023 092 638 928 076 8 × 2 = 0 + 0.000 000 000 000 046 185 277 856 153 6;
  • 19) 0.000 000 000 000 046 185 277 856 153 6 × 2 = 0 + 0.000 000 000 000 092 370 555 712 307 2;
  • 20) 0.000 000 000 000 092 370 555 712 307 2 × 2 = 0 + 0.000 000 000 000 184 741 111 424 614 4;
  • 21) 0.000 000 000 000 184 741 111 424 614 4 × 2 = 0 + 0.000 000 000 000 369 482 222 849 228 8;
  • 22) 0.000 000 000 000 369 482 222 849 228 8 × 2 = 0 + 0.000 000 000 000 738 964 445 698 457 6;
  • 23) 0.000 000 000 000 738 964 445 698 457 6 × 2 = 0 + 0.000 000 000 001 477 928 891 396 915 2;
  • 24) 0.000 000 000 001 477 928 891 396 915 2 × 2 = 0 + 0.000 000 000 002 955 857 782 793 830 4;
  • 25) 0.000 000 000 002 955 857 782 793 830 4 × 2 = 0 + 0.000 000 000 005 911 715 565 587 660 8;
  • 26) 0.000 000 000 005 911 715 565 587 660 8 × 2 = 0 + 0.000 000 000 011 823 431 131 175 321 6;
  • 27) 0.000 000 000 011 823 431 131 175 321 6 × 2 = 0 + 0.000 000 000 023 646 862 262 350 643 2;
  • 28) 0.000 000 000 023 646 862 262 350 643 2 × 2 = 0 + 0.000 000 000 047 293 724 524 701 286 4;
  • 29) 0.000 000 000 047 293 724 524 701 286 4 × 2 = 0 + 0.000 000 000 094 587 449 049 402 572 8;
  • 30) 0.000 000 000 094 587 449 049 402 572 8 × 2 = 0 + 0.000 000 000 189 174 898 098 805 145 6;
  • 31) 0.000 000 000 189 174 898 098 805 145 6 × 2 = 0 + 0.000 000 000 378 349 796 197 610 291 2;
  • 32) 0.000 000 000 378 349 796 197 610 291 2 × 2 = 0 + 0.000 000 000 756 699 592 395 220 582 4;
  • 33) 0.000 000 000 756 699 592 395 220 582 4 × 2 = 0 + 0.000 000 001 513 399 184 790 441 164 8;
  • 34) 0.000 000 001 513 399 184 790 441 164 8 × 2 = 0 + 0.000 000 003 026 798 369 580 882 329 6;
  • 35) 0.000 000 003 026 798 369 580 882 329 6 × 2 = 0 + 0.000 000 006 053 596 739 161 764 659 2;
  • 36) 0.000 000 006 053 596 739 161 764 659 2 × 2 = 0 + 0.000 000 012 107 193 478 323 529 318 4;
  • 37) 0.000 000 012 107 193 478 323 529 318 4 × 2 = 0 + 0.000 000 024 214 386 956 647 058 636 8;
  • 38) 0.000 000 024 214 386 956 647 058 636 8 × 2 = 0 + 0.000 000 048 428 773 913 294 117 273 6;
  • 39) 0.000 000 048 428 773 913 294 117 273 6 × 2 = 0 + 0.000 000 096 857 547 826 588 234 547 2;
  • 40) 0.000 000 096 857 547 826 588 234 547 2 × 2 = 0 + 0.000 000 193 715 095 653 176 469 094 4;
  • 41) 0.000 000 193 715 095 653 176 469 094 4 × 2 = 0 + 0.000 000 387 430 191 306 352 938 188 8;
  • 42) 0.000 000 387 430 191 306 352 938 188 8 × 2 = 0 + 0.000 000 774 860 382 612 705 876 377 6;
  • 43) 0.000 000 774 860 382 612 705 876 377 6 × 2 = 0 + 0.000 001 549 720 765 225 411 752 755 2;
  • 44) 0.000 001 549 720 765 225 411 752 755 2 × 2 = 0 + 0.000 003 099 441 530 450 823 505 510 4;
  • 45) 0.000 003 099 441 530 450 823 505 510 4 × 2 = 0 + 0.000 006 198 883 060 901 647 011 020 8;
  • 46) 0.000 006 198 883 060 901 647 011 020 8 × 2 = 0 + 0.000 012 397 766 121 803 294 022 041 6;
  • 47) 0.000 012 397 766 121 803 294 022 041 6 × 2 = 0 + 0.000 024 795 532 243 606 588 044 083 2;
  • 48) 0.000 024 795 532 243 606 588 044 083 2 × 2 = 0 + 0.000 049 591 064 487 213 176 088 166 4;
  • 49) 0.000 049 591 064 487 213 176 088 166 4 × 2 = 0 + 0.000 099 182 128 974 426 352 176 332 8;
  • 50) 0.000 099 182 128 974 426 352 176 332 8 × 2 = 0 + 0.000 198 364 257 948 852 704 352 665 6;
  • 51) 0.000 198 364 257 948 852 704 352 665 6 × 2 = 0 + 0.000 396 728 515 897 705 408 705 331 2;
  • 52) 0.000 396 728 515 897 705 408 705 331 2 × 2 = 0 + 0.000 793 457 031 795 410 817 410 662 4;
  • 53) 0.000 793 457 031 795 410 817 410 662 4 × 2 = 0 + 0.001 586 914 063 590 821 634 821 324 8;
  • 54) 0.001 586 914 063 590 821 634 821 324 8 × 2 = 0 + 0.003 173 828 127 181 643 269 642 649 6;
  • 55) 0.003 173 828 127 181 643 269 642 649 6 × 2 = 0 + 0.006 347 656 254 363 286 539 285 299 2;
  • 56) 0.006 347 656 254 363 286 539 285 299 2 × 2 = 0 + 0.012 695 312 508 726 573 078 570 598 4;
  • 57) 0.012 695 312 508 726 573 078 570 598 4 × 2 = 0 + 0.025 390 625 017 453 146 157 141 196 8;
  • 58) 0.025 390 625 017 453 146 157 141 196 8 × 2 = 0 + 0.050 781 250 034 906 292 314 282 393 6;
  • 59) 0.050 781 250 034 906 292 314 282 393 6 × 2 = 0 + 0.101 562 500 069 812 584 628 564 787 2;
  • 60) 0.101 562 500 069 812 584 628 564 787 2 × 2 = 0 + 0.203 125 000 139 625 169 257 129 574 4;
  • 61) 0.203 125 000 139 625 169 257 129 574 4 × 2 = 0 + 0.406 250 000 279 250 338 514 259 148 8;
  • 62) 0.406 250 000 279 250 338 514 259 148 8 × 2 = 0 + 0.812 500 000 558 500 677 028 518 297 6;
  • 63) 0.812 500 000 558 500 677 028 518 297 6 × 2 = 1 + 0.625 000 001 117 001 354 057 036 595 2;
  • 64) 0.625 000 001 117 001 354 057 036 595 2 × 2 = 1 + 0.250 000 002 234 002 708 114 073 190 4;
  • 65) 0.250 000 002 234 002 708 114 073 190 4 × 2 = 0 + 0.500 000 004 468 005 416 228 146 380 8;
  • 66) 0.500 000 004 468 005 416 228 146 380 8 × 2 = 1 + 0.000 000 008 936 010 832 456 292 761 6;
  • 67) 0.000 000 008 936 010 832 456 292 761 6 × 2 = 0 + 0.000 000 017 872 021 664 912 585 523 2;
  • 68) 0.000 000 017 872 021 664 912 585 523 2 × 2 = 0 + 0.000 000 035 744 043 329 825 171 046 4;
  • 69) 0.000 000 035 744 043 329 825 171 046 4 × 2 = 0 + 0.000 000 071 488 086 659 650 342 092 8;
  • 70) 0.000 000 071 488 086 659 650 342 092 8 × 2 = 0 + 0.000 000 142 976 173 319 300 684 185 6;
  • 71) 0.000 000 142 976 173 319 300 684 185 6 × 2 = 0 + 0.000 000 285 952 346 638 601 368 371 2;
  • 72) 0.000 000 285 952 346 638 601 368 371 2 × 2 = 0 + 0.000 000 571 904 693 277 202 736 742 4;
  • 73) 0.000 000 571 904 693 277 202 736 742 4 × 2 = 0 + 0.000 001 143 809 386 554 405 473 484 8;
  • 74) 0.000 001 143 809 386 554 405 473 484 8 × 2 = 0 + 0.000 002 287 618 773 108 810 946 969 6;
  • 75) 0.000 002 287 618 773 108 810 946 969 6 × 2 = 0 + 0.000 004 575 237 546 217 621 893 939 2;
  • 76) 0.000 004 575 237 546 217 621 893 939 2 × 2 = 0 + 0.000 009 150 475 092 435 243 787 878 4;
  • 77) 0.000 009 150 475 092 435 243 787 878 4 × 2 = 0 + 0.000 018 300 950 184 870 487 575 756 8;
  • 78) 0.000 018 300 950 184 870 487 575 756 8 × 2 = 0 + 0.000 036 601 900 369 740 975 151 513 6;
  • 79) 0.000 036 601 900 369 740 975 151 513 6 × 2 = 0 + 0.000 073 203 800 739 481 950 303 027 2;
  • 80) 0.000 073 203 800 739 481 950 303 027 2 × 2 = 0 + 0.000 146 407 601 478 963 900 606 054 4;
  • 81) 0.000 146 407 601 478 963 900 606 054 4 × 2 = 0 + 0.000 292 815 202 957 927 801 212 108 8;
  • 82) 0.000 292 815 202 957 927 801 212 108 8 × 2 = 0 + 0.000 585 630 405 915 855 602 424 217 6;
  • 83) 0.000 585 630 405 915 855 602 424 217 6 × 2 = 0 + 0.001 171 260 811 831 711 204 848 435 2;
  • 84) 0.001 171 260 811 831 711 204 848 435 2 × 2 = 0 + 0.002 342 521 623 663 422 409 696 870 4;
  • 85) 0.002 342 521 623 663 422 409 696 870 4 × 2 = 0 + 0.004 685 043 247 326 844 819 393 740 8;
  • 86) 0.004 685 043 247 326 844 819 393 740 8 × 2 = 0 + 0.009 370 086 494 653 689 638 787 481 6;

We didn't get any fractional part that was equal to zero. But we had enough iterations (over Mantissa limit) and at least one integer that was different from zero => FULL STOP (Losing precision - the converted number we get in the end will be just a very good approximation of the initial one).


4. Construct the base 2 representation of the fractional part of the number.

Take all the integer parts of the multiplying operations, starting from the top of the constructed list above:


0.000 000 000 000 000 000 176 182 853 15(10) =

0.0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0011 0100 0000 0000 0000 0000 00(2)

5. Positive number before normalization:

0.000 000 000 000 000 000 176 182 853 15(10) =

0.0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0011 0100 0000 0000 0000 0000 00(2)

6. Normalize the binary representation of the number.

Shift the decimal mark 63 positions to the right, so that only one non zero digit remains to the left of it:


0.000 000 000 000 000 000 176 182 853 15(10) =

0.0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0011 0100 0000 0000 0000 0000 00(2) =

0.0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0011 0100 0000 0000 0000 0000 00(2) × 20 =

1.1010 0000 0000 0000 0000 000(2) × 2-63


7. Up to this moment, there are the following elements that would feed into the 32 bit single precision IEEE 754 binary floating point representation:

Sign 0 (a positive number)

Exponent (unadjusted): -63

Mantissa (not normalized):
1.1010 0000 0000 0000 0000 000


8. Adjust the exponent.

Use the 8 bit excess/bias notation:


Exponent (adjusted) =

Exponent (unadjusted) + 2(8-1) - 1 =

-63 + 2(8-1) - 1 =

(-63 + 127)(10) =

64(10)


9. Convert the adjusted exponent from the decimal (base 10) to 8 bit binary.

Use the same technique of repeatedly dividing by 2:


  • division = quotient + remainder;
  • 64 ÷ 2 = 32 + 0;
  • 32 ÷ 2 = 16 + 0;
  • 16 ÷ 2 = 8 + 0;
  • 8 ÷ 2 = 4 + 0;
  • 4 ÷ 2 = 2 + 0;
  • 2 ÷ 2 = 1 + 0;
  • 1 ÷ 2 = 0 + 1;

10. Construct the base 2 representation of the adjusted exponent.

Take all the remainders starting from the bottom of the list constructed above.


Exponent (adjusted) =

64(10) =

0100 0000(2)


11. Normalize the mantissa.

a) Remove the leading (the leftmost) bit, since it's allways 1, and the decimal point, if the case.

b) Adjust its length to 23 bits, only if necessary (not the case here).


Mantissa (normalized) =

1. 101 0000 0000 0000 0000 0000 =

101 0000 0000 0000 0000 0000


12. The three elements that make up the number's 32 bit single precision IEEE 754 binary floating point representation:

Sign (1 bit) =
0 (a positive number)

Exponent (8 bits) =
0100 0000

Mantissa (23 bits) =
101 0000 0000 0000 0000 0000


Decimal number 0.000 000 000 000 000 000 176 182 853 15 converted to 32 bit single precision IEEE 754 binary floating point representation:

0 - 0100 0000 - 101 0000 0000 0000 0000 0000

Share

» Convert decimal 0.000 000 000 000 000 000 176 182 853 46 to 32 bit single precision IEEE 754 binary floating point representation standard

» Calculations Performed by Our Visitors: Decimal Numbers Converted to 32 Bit Single Precision IEEE 754 Binary Floating Point Representation Standard. Data organized on a Monthly Basis

» Month 09, 2026 [September]: Decimal Numbers Converted to 32 Bit Single Precision IEEE 754 Binary Floating Point Representation Standard. Calculations performed during the month of: September - by our visitors

» Improve your social skills: My Manager Only Says “We” When Referring to “My Work”. Gemini Notebook YouTube Video of 11.13 minutes

How to convert decimal numbers from base ten to 32 bit single precision IEEE 754 binary floating point standard

Follow the steps below to convert a base 10 decimal number to 32 bit single precision IEEE 754 binary floating point:

  • 1. If the number to be converted is negative, start with its the positive version.
  • 2. First convert the integer part. Divide repeatedly by 2 the base ten positive representation of the integer number that is to be converted to binary, until we get a quotient that is equal to zero, keeping track of each remainder.
  • 3. Construct the base 2 representation of the positive integer part of the number, by taking all the remainders of the previous dividing operations, starting from the bottom of the list constructed above. Thus, the last remainder of the divisions becomes the first symbol (the leftmost) of the base two number, while the first remainder becomes the last symbol (the rightmost).
  • 4. Then convert the fractional part. Multiply the number repeatedly by 2, until we get a fractional part that is equal to zero, keeping track of each integer part of the results.
  • 5. Construct the base 2 representation of the fractional part of the number by taking all the integer parts of the previous multiplying operations, starting from the top of the constructed list above (they should appear in the binary representation, from left to right, in the order they have been calculated).
  • 6. Normalize the binary representation of the number, by shifting the decimal point (or if you prefer, the decimal mark) "n" positions either to the left or to the right, so that only one non zero digit remains to the left of the decimal point.
  • 7. Adjust the exponent in 8 bit excess/bias notation and then convert it from decimal (base 10) to 8 bit binary, by using the same technique of repeatedly dividing by 2, as shown above:
    Exponent (adjusted) = Exponent (unadjusted) + 2(8-1) - 1
  • 8. Normalize mantissa, remove the leading (leftmost) bit, since it's allways '1' (and the decimal sign if the case) and adjust its length to 23 bits, either by removing the excess bits from the right (losing precision...) or by adding extra '0' bits to the right.
  • 9. Sign (it takes 1 bit) is either 1 for a negative or 0 for a positive number.

Example: convert the negative number -25.347 from decimal system (base ten) to 32 bit single precision IEEE 754 binary floating point:

  • 1. Start with the positive version of the number:

    |-25.347| = 25.347

  • 2. First convert the integer part, 25. Divide it repeatedly by 2, keeping track of each remainder, until we get a quotient that is equal to zero:
    • division = quotient + remainder;
    • 25 ÷ 2 = 12 + 1;
    • 12 ÷ 2 = 6 + 0;
    • 6 ÷ 2 = 3 + 0;
    • 3 ÷ 2 = 1 + 1;
    • 1 ÷ 2 = 0 + 1;
    • We have encountered a quotient that is ZERO => FULL STOP
  • 3. Construct the base 2 representation of the integer part of the number by taking all the remainders of the previous dividing operations, starting from the bottom of the list constructed above:

    25(10) = 1 1001(2)

  • 4. Then convert the fractional part, 0.347. Multiply repeatedly by 2, keeping track of each integer part of the results, until we get a fractional part that is equal to zero:
    • #) multiplying = integer + fractional part;
    • 1) 0.347 × 2 = 0 + 0.694;
    • 2) 0.694 × 2 = 1 + 0.388;
    • 3) 0.388 × 2 = 0 + 0.776;
    • 4) 0.776 × 2 = 1 + 0.552;
    • 5) 0.552 × 2 = 1 + 0.104;
    • 6) 0.104 × 2 = 0 + 0.208;
    • 7) 0.208 × 2 = 0 + 0.416;
    • 8) 0.416 × 2 = 0 + 0.832;
    • 9) 0.832 × 2 = 1 + 0.664;
    • 10) 0.664 × 2 = 1 + 0.328;
    • 11) 0.328 × 2 = 0 + 0.656;
    • 12) 0.656 × 2 = 1 + 0.312;
    • 13) 0.312 × 2 = 0 + 0.624;
    • 14) 0.624 × 2 = 1 + 0.248;
    • 15) 0.248 × 2 = 0 + 0.496;
    • 16) 0.496 × 2 = 0 + 0.992;
    • 17) 0.992 × 2 = 1 + 0.984;
    • 18) 0.984 × 2 = 1 + 0.968;
    • 19) 0.968 × 2 = 1 + 0.936;
    • 20) 0.936 × 2 = 1 + 0.872;
    • 21) 0.872 × 2 = 1 + 0.744;
    • 22) 0.744 × 2 = 1 + 0.488;
    • 23) 0.488 × 2 = 0 + 0.976;
    • 24) 0.976 × 2 = 1 + 0.952;
    • We didn't get any fractional part that was equal to zero. But we had enough iterations (over Mantissa limit = 23) and at least one integer part that was different from zero => FULL STOP (losing precision...).
  • 5. Construct the base 2 representation of the fractional part of the number, by taking all the integer parts of the previous multiplying operations, starting from the top of the constructed list above:

    0.347(10) = 0.0101 1000 1101 0100 1111 1101(2)

  • 6. Summarizing - the positive number before normalization:

    25.347(10) = 1 1001.0101 1000 1101 0100 1111 1101(2)

  • 7. Normalize the binary representation of the number, shifting the decimal point 4 positions to the left so that only one non-zero digit stays to the left of the decimal point:

    25.347(10) =
    1 1001.0101 1000 1101 0100 1111 1101(2) =
    1 1001.0101 1000 1101 0100 1111 1101(2) × 20 =
    1.1001 0101 1000 1101 0100 1111 1101(2) × 24

  • 8. Up to this moment, there are the following elements that would feed into the 32 bit single precision IEEE 754 binary floating point:

    Sign: 1 (a negative number)

    Exponent (unadjusted): 4

    Mantissa (not-normalized): 1.1001 0101 1000 1101 0100 1111 1101

  • 9. Adjust the exponent in 8 bit excess/bias notation and then convert it from decimal (base 10) to 8 bit binary (base 2), by using the same technique of repeatedly dividing it by 2, as already demonstrated above:

    Exponent (adjusted) = Exponent (unadjusted) + 2(8-1) - 1 = (4 + 127)(10) = 131(10) =
    1000 0011(2)

  • 10. Normalize the mantissa, remove the leading (leftmost) bit, since it's allways '1' (and the decimal point) and adjust its length to 23 bits, by removing the excess bits from the right (losing precision...):

    Mantissa (not-normalized): 1.1001 0101 1000 1101 0100 1111 1101

    Mantissa (normalized): 100 1010 1100 0110 1010 0111

  • Conclusion:

    Sign (1 bit) = 1 (a negative number)

    Exponent (8 bits) = 1000 0011

    Mantissa (23 bits) = 100 1010 1100 0110 1010 0111

  • Number -25.347, converted from the decimal system (base 10) to 32 bit single precision IEEE 754 binary floating point =
    1 - 1000 0011 - 100 1010 1100 0110 1010 0111