Convert 1 000 001 001 001 100 000 000 000 000 018 to 32 Bit Single Precision IEEE 754 Binary Floating Point Standard, From a Base 10 Decimal Number

1 000 001 001 001 100 000 000 000 000 018(10) to 32 bit single precision IEEE 754 binary floating point (1 bit for sign, 8 bits for exponent, 23 bits for mantissa) = ?

1. 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;
  • 1 000 001 001 001 100 000 000 000 000 018 ÷ 2 = 500 000 500 500 550 000 000 000 000 009 + 0;
  • 500 000 500 500 550 000 000 000 000 009 ÷ 2 = 250 000 250 250 275 000 000 000 000 004 + 1;
  • 250 000 250 250 275 000 000 000 000 004 ÷ 2 = 125 000 125 125 137 500 000 000 000 002 + 0;
  • 125 000 125 125 137 500 000 000 000 002 ÷ 2 = 62 500 062 562 568 750 000 000 000 001 + 0;
  • 62 500 062 562 568 750 000 000 000 001 ÷ 2 = 31 250 031 281 284 375 000 000 000 000 + 1;
  • 31 250 031 281 284 375 000 000 000 000 ÷ 2 = 15 625 015 640 642 187 500 000 000 000 + 0;
  • 15 625 015 640 642 187 500 000 000 000 ÷ 2 = 7 812 507 820 321 093 750 000 000 000 + 0;
  • 7 812 507 820 321 093 750 000 000 000 ÷ 2 = 3 906 253 910 160 546 875 000 000 000 + 0;
  • 3 906 253 910 160 546 875 000 000 000 ÷ 2 = 1 953 126 955 080 273 437 500 000 000 + 0;
  • 1 953 126 955 080 273 437 500 000 000 ÷ 2 = 976 563 477 540 136 718 750 000 000 + 0;
  • 976 563 477 540 136 718 750 000 000 ÷ 2 = 488 281 738 770 068 359 375 000 000 + 0;
  • 488 281 738 770 068 359 375 000 000 ÷ 2 = 244 140 869 385 034 179 687 500 000 + 0;
  • 244 140 869 385 034 179 687 500 000 ÷ 2 = 122 070 434 692 517 089 843 750 000 + 0;
  • 122 070 434 692 517 089 843 750 000 ÷ 2 = 61 035 217 346 258 544 921 875 000 + 0;
  • 61 035 217 346 258 544 921 875 000 ÷ 2 = 30 517 608 673 129 272 460 937 500 + 0;
  • 30 517 608 673 129 272 460 937 500 ÷ 2 = 15 258 804 336 564 636 230 468 750 + 0;
  • 15 258 804 336 564 636 230 468 750 ÷ 2 = 7 629 402 168 282 318 115 234 375 + 0;
  • 7 629 402 168 282 318 115 234 375 ÷ 2 = 3 814 701 084 141 159 057 617 187 + 1;
  • 3 814 701 084 141 159 057 617 187 ÷ 2 = 1 907 350 542 070 579 528 808 593 + 1;
  • 1 907 350 542 070 579 528 808 593 ÷ 2 = 953 675 271 035 289 764 404 296 + 1;
  • 953 675 271 035 289 764 404 296 ÷ 2 = 476 837 635 517 644 882 202 148 + 0;
  • 476 837 635 517 644 882 202 148 ÷ 2 = 238 418 817 758 822 441 101 074 + 0;
  • 238 418 817 758 822 441 101 074 ÷ 2 = 119 209 408 879 411 220 550 537 + 0;
  • 119 209 408 879 411 220 550 537 ÷ 2 = 59 604 704 439 705 610 275 268 + 1;
  • 59 604 704 439 705 610 275 268 ÷ 2 = 29 802 352 219 852 805 137 634 + 0;
  • 29 802 352 219 852 805 137 634 ÷ 2 = 14 901 176 109 926 402 568 817 + 0;
  • 14 901 176 109 926 402 568 817 ÷ 2 = 7 450 588 054 963 201 284 408 + 1;
  • 7 450 588 054 963 201 284 408 ÷ 2 = 3 725 294 027 481 600 642 204 + 0;
  • 3 725 294 027 481 600 642 204 ÷ 2 = 1 862 647 013 740 800 321 102 + 0;
  • 1 862 647 013 740 800 321 102 ÷ 2 = 931 323 506 870 400 160 551 + 0;
  • 931 323 506 870 400 160 551 ÷ 2 = 465 661 753 435 200 080 275 + 1;
  • 465 661 753 435 200 080 275 ÷ 2 = 232 830 876 717 600 040 137 + 1;
  • 232 830 876 717 600 040 137 ÷ 2 = 116 415 438 358 800 020 068 + 1;
  • 116 415 438 358 800 020 068 ÷ 2 = 58 207 719 179 400 010 034 + 0;
  • 58 207 719 179 400 010 034 ÷ 2 = 29 103 859 589 700 005 017 + 0;
  • 29 103 859 589 700 005 017 ÷ 2 = 14 551 929 794 850 002 508 + 1;
  • 14 551 929 794 850 002 508 ÷ 2 = 7 275 964 897 425 001 254 + 0;
  • 7 275 964 897 425 001 254 ÷ 2 = 3 637 982 448 712 500 627 + 0;
  • 3 637 982 448 712 500 627 ÷ 2 = 1 818 991 224 356 250 313 + 1;
  • 1 818 991 224 356 250 313 ÷ 2 = 909 495 612 178 125 156 + 1;
  • 909 495 612 178 125 156 ÷ 2 = 454 747 806 089 062 578 + 0;
  • 454 747 806 089 062 578 ÷ 2 = 227 373 903 044 531 289 + 0;
  • 227 373 903 044 531 289 ÷ 2 = 113 686 951 522 265 644 + 1;
  • 113 686 951 522 265 644 ÷ 2 = 56 843 475 761 132 822 + 0;
  • 56 843 475 761 132 822 ÷ 2 = 28 421 737 880 566 411 + 0;
  • 28 421 737 880 566 411 ÷ 2 = 14 210 868 940 283 205 + 1;
  • 14 210 868 940 283 205 ÷ 2 = 7 105 434 470 141 602 + 1;
  • 7 105 434 470 141 602 ÷ 2 = 3 552 717 235 070 801 + 0;
  • 3 552 717 235 070 801 ÷ 2 = 1 776 358 617 535 400 + 1;
  • 1 776 358 617 535 400 ÷ 2 = 888 179 308 767 700 + 0;
  • 888 179 308 767 700 ÷ 2 = 444 089 654 383 850 + 0;
  • 444 089 654 383 850 ÷ 2 = 222 044 827 191 925 + 0;
  • 222 044 827 191 925 ÷ 2 = 111 022 413 595 962 + 1;
  • 111 022 413 595 962 ÷ 2 = 55 511 206 797 981 + 0;
  • 55 511 206 797 981 ÷ 2 = 27 755 603 398 990 + 1;
  • 27 755 603 398 990 ÷ 2 = 13 877 801 699 495 + 0;
  • 13 877 801 699 495 ÷ 2 = 6 938 900 849 747 + 1;
  • 6 938 900 849 747 ÷ 2 = 3 469 450 424 873 + 1;
  • 3 469 450 424 873 ÷ 2 = 1 734 725 212 436 + 1;
  • 1 734 725 212 436 ÷ 2 = 867 362 606 218 + 0;
  • 867 362 606 218 ÷ 2 = 433 681 303 109 + 0;
  • 433 681 303 109 ÷ 2 = 216 840 651 554 + 1;
  • 216 840 651 554 ÷ 2 = 108 420 325 777 + 0;
  • 108 420 325 777 ÷ 2 = 54 210 162 888 + 1;
  • 54 210 162 888 ÷ 2 = 27 105 081 444 + 0;
  • 27 105 081 444 ÷ 2 = 13 552 540 722 + 0;
  • 13 552 540 722 ÷ 2 = 6 776 270 361 + 0;
  • 6 776 270 361 ÷ 2 = 3 388 135 180 + 1;
  • 3 388 135 180 ÷ 2 = 1 694 067 590 + 0;
  • 1 694 067 590 ÷ 2 = 847 033 795 + 0;
  • 847 033 795 ÷ 2 = 423 516 897 + 1;
  • 423 516 897 ÷ 2 = 211 758 448 + 1;
  • 211 758 448 ÷ 2 = 105 879 224 + 0;
  • 105 879 224 ÷ 2 = 52 939 612 + 0;
  • 52 939 612 ÷ 2 = 26 469 806 + 0;
  • 26 469 806 ÷ 2 = 13 234 903 + 0;
  • 13 234 903 ÷ 2 = 6 617 451 + 1;
  • 6 617 451 ÷ 2 = 3 308 725 + 1;
  • 3 308 725 ÷ 2 = 1 654 362 + 1;
  • 1 654 362 ÷ 2 = 827 181 + 0;
  • 827 181 ÷ 2 = 413 590 + 1;
  • 413 590 ÷ 2 = 206 795 + 0;
  • 206 795 ÷ 2 = 103 397 + 1;
  • 103 397 ÷ 2 = 51 698 + 1;
  • 51 698 ÷ 2 = 25 849 + 0;
  • 25 849 ÷ 2 = 12 924 + 1;
  • 12 924 ÷ 2 = 6 462 + 0;
  • 6 462 ÷ 2 = 3 231 + 0;
  • 3 231 ÷ 2 = 1 615 + 1;
  • 1 615 ÷ 2 = 807 + 1;
  • 807 ÷ 2 = 403 + 1;
  • 403 ÷ 2 = 201 + 1;
  • 201 ÷ 2 = 100 + 1;
  • 100 ÷ 2 = 50 + 0;
  • 50 ÷ 2 = 25 + 0;
  • 25 ÷ 2 = 12 + 1;
  • 12 ÷ 2 = 6 + 0;
  • 6 ÷ 2 = 3 + 0;
  • 3 ÷ 2 = 1 + 1;
  • 1 ÷ 2 = 0 + 1;

2. Construct the base 2 representation of the positive number.

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


1 000 001 001 001 100 000 000 000 000 018(10) =


1100 1001 1111 0010 1101 0111 0000 1100 1000 1010 0111 0101 0001 0110 0100 1100 1001 1100 0100 1000 1110 0000 0000 0001 0010(2)


3. Normalize the binary representation of the number.

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


1 000 001 001 001 100 000 000 000 000 018(10) =


1100 1001 1111 0010 1101 0111 0000 1100 1000 1010 0111 0101 0001 0110 0100 1100 1001 1100 0100 1000 1110 0000 0000 0001 0010(2) =


1100 1001 1111 0010 1101 0111 0000 1100 1000 1010 0111 0101 0001 0110 0100 1100 1001 1100 0100 1000 1110 0000 0000 0001 0010(2) × 20 =


1.1001 0011 1110 0101 1010 1110 0001 1001 0001 0100 1110 1010 0010 1100 1001 1001 0011 1000 1001 0001 1100 0000 0000 0010 010(2) × 299


4. 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): 99


Mantissa (not normalized):
1.1001 0011 1110 0101 1010 1110 0001 1001 0001 0100 1110 1010 0010 1100 1001 1001 0011 1000 1001 0001 1100 0000 0000 0010 010


5. Adjust the exponent.

Use the 8 bit excess/bias notation:


Exponent (adjusted) =


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


99 + 2(8-1) - 1 =


(99 + 127)(10) =


226(10)


6. 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;
  • 226 ÷ 2 = 113 + 0;
  • 113 ÷ 2 = 56 + 1;
  • 56 ÷ 2 = 28 + 0;
  • 28 ÷ 2 = 14 + 0;
  • 14 ÷ 2 = 7 + 0;
  • 7 ÷ 2 = 3 + 1;
  • 3 ÷ 2 = 1 + 1;
  • 1 ÷ 2 = 0 + 1;

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

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


Exponent (adjusted) =


226(10) =


1110 0010(2)


8. 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, by removing the excess bits, from the right (if any of the excess bits is set on 1, we are losing precision...).


Mantissa (normalized) =


1. 100 1001 1111 0010 1101 0111 0000 1100 1000 1010 0111 0101 0001 0110 0100 1100 1001 1100 0100 1000 1110 0000 0000 0001 0010 =


100 1001 1111 0010 1101 0111


9. 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) =
1110 0010


Mantissa (23 bits) =
100 1001 1111 0010 1101 0111


Number 1 000 001 001 001 100 000 000 000 000 018 converted from decimal system (base 10) to 32 bit single precision IEEE 754 binary floating point:
0 - 1110 0010 - 100 1001 1111 0010 1101 0111

(32 bits IEEE 754)

More operations of this kind:

1 000 001 001 001 100 000 000 000 000 017 = ? ... 1 000 001 001 001 100 000 000 000 000 019 = ?


Convert to 32 bit single precision IEEE 754 binary floating point standard

A number in 32 bit single precision IEEE 754 binary floating point standard representation requires three building elements: sign (it takes 1 bit and it's either 0 for positive or 1 for negative numbers), exponent (8 bits) and mantissa (23 bits)

Latest decimal numbers converted from base ten to 32 bit single precision IEEE 754 floating point binary standard representation

1 000 001 001 001 100 000 000 000 000 018 to 32 bit single precision IEEE 754 binary floating point = ? Feb 04 09:21 UTC (GMT)
20.49 to 32 bit single precision IEEE 754 binary floating point = ? Feb 04 09:21 UTC (GMT)
0.002 515 04 to 32 bit single precision IEEE 754 binary floating point = ? Feb 04 09:21 UTC (GMT)
1 260 206 582 to 32 bit single precision IEEE 754 binary floating point = ? Feb 04 09:21 UTC (GMT)
72.34 to 32 bit single precision IEEE 754 binary floating point = ? Feb 04 09:21 UTC (GMT)
10.820 5 to 32 bit single precision IEEE 754 binary floating point = ? Feb 04 09:21 UTC (GMT)
125 649 to 32 bit single precision IEEE 754 binary floating point = ? Feb 04 09:21 UTC (GMT)
0.165 8 to 32 bit single precision IEEE 754 binary floating point = ? Feb 04 09:21 UTC (GMT)
5 819 780 to 32 bit single precision IEEE 754 binary floating point = ? Feb 04 09:20 UTC (GMT)
159 to 32 bit single precision IEEE 754 binary floating point = ? Feb 04 09:20 UTC (GMT)
1 100 111 000 110 080 to 32 bit single precision IEEE 754 binary floating point = ? Feb 04 09:20 UTC (GMT)
0.004 93 to 32 bit single precision IEEE 754 binary floating point = ? Feb 04 09:20 UTC (GMT)
613 566 768 to 32 bit single precision IEEE 754 binary floating point = ? Feb 04 09:20 UTC (GMT)
All base ten decimal numbers converted to 32 bit single precision IEEE 754 binary floating point

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