32bit IEEE 754: Decimal ↗ Single Precision Floating Point Binary: -0.000 000 000 000 000 002 11 Convert the Number to 32 Bit Single Precision IEEE 754 Binary Floating Point Representation Standard, From a Base 10 Decimal System Number

Number -0.000 000 000 000 000 002 11(10) converted and written in 32 bit single precision IEEE 754 binary floating point representation (1 bit for sign, 8 bits for exponent, 23 bits for mantissa)

1. Start with the positive version of the number:

|-0.000 000 000 000 000 002 11| = 0.000 000 000 000 000 002 11

2. 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;

3. 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)


4. Convert to binary (base 2) the fractional part: 0.000 000 000 000 000 002 11.

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 002 11 × 2 = 0 + 0.000 000 000 000 000 004 22;
  • 2) 0.000 000 000 000 000 004 22 × 2 = 0 + 0.000 000 000 000 000 008 44;
  • 3) 0.000 000 000 000 000 008 44 × 2 = 0 + 0.000 000 000 000 000 016 88;
  • 4) 0.000 000 000 000 000 016 88 × 2 = 0 + 0.000 000 000 000 000 033 76;
  • 5) 0.000 000 000 000 000 033 76 × 2 = 0 + 0.000 000 000 000 000 067 52;
  • 6) 0.000 000 000 000 000 067 52 × 2 = 0 + 0.000 000 000 000 000 135 04;
  • 7) 0.000 000 000 000 000 135 04 × 2 = 0 + 0.000 000 000 000 000 270 08;
  • 8) 0.000 000 000 000 000 270 08 × 2 = 0 + 0.000 000 000 000 000 540 16;
  • 9) 0.000 000 000 000 000 540 16 × 2 = 0 + 0.000 000 000 000 001 080 32;
  • 10) 0.000 000 000 000 001 080 32 × 2 = 0 + 0.000 000 000 000 002 160 64;
  • 11) 0.000 000 000 000 002 160 64 × 2 = 0 + 0.000 000 000 000 004 321 28;
  • 12) 0.000 000 000 000 004 321 28 × 2 = 0 + 0.000 000 000 000 008 642 56;
  • 13) 0.000 000 000 000 008 642 56 × 2 = 0 + 0.000 000 000 000 017 285 12;
  • 14) 0.000 000 000 000 017 285 12 × 2 = 0 + 0.000 000 000 000 034 570 24;
  • 15) 0.000 000 000 000 034 570 24 × 2 = 0 + 0.000 000 000 000 069 140 48;
  • 16) 0.000 000 000 000 069 140 48 × 2 = 0 + 0.000 000 000 000 138 280 96;
  • 17) 0.000 000 000 000 138 280 96 × 2 = 0 + 0.000 000 000 000 276 561 92;
  • 18) 0.000 000 000 000 276 561 92 × 2 = 0 + 0.000 000 000 000 553 123 84;
  • 19) 0.000 000 000 000 553 123 84 × 2 = 0 + 0.000 000 000 001 106 247 68;
  • 20) 0.000 000 000 001 106 247 68 × 2 = 0 + 0.000 000 000 002 212 495 36;
  • 21) 0.000 000 000 002 212 495 36 × 2 = 0 + 0.000 000 000 004 424 990 72;
  • 22) 0.000 000 000 004 424 990 72 × 2 = 0 + 0.000 000 000 008 849 981 44;
  • 23) 0.000 000 000 008 849 981 44 × 2 = 0 + 0.000 000 000 017 699 962 88;
  • 24) 0.000 000 000 017 699 962 88 × 2 = 0 + 0.000 000 000 035 399 925 76;
  • 25) 0.000 000 000 035 399 925 76 × 2 = 0 + 0.000 000 000 070 799 851 52;
  • 26) 0.000 000 000 070 799 851 52 × 2 = 0 + 0.000 000 000 141 599 703 04;
  • 27) 0.000 000 000 141 599 703 04 × 2 = 0 + 0.000 000 000 283 199 406 08;
  • 28) 0.000 000 000 283 199 406 08 × 2 = 0 + 0.000 000 000 566 398 812 16;
  • 29) 0.000 000 000 566 398 812 16 × 2 = 0 + 0.000 000 001 132 797 624 32;
  • 30) 0.000 000 001 132 797 624 32 × 2 = 0 + 0.000 000 002 265 595 248 64;
  • 31) 0.000 000 002 265 595 248 64 × 2 = 0 + 0.000 000 004 531 190 497 28;
  • 32) 0.000 000 004 531 190 497 28 × 2 = 0 + 0.000 000 009 062 380 994 56;
  • 33) 0.000 000 009 062 380 994 56 × 2 = 0 + 0.000 000 018 124 761 989 12;
  • 34) 0.000 000 018 124 761 989 12 × 2 = 0 + 0.000 000 036 249 523 978 24;
  • 35) 0.000 000 036 249 523 978 24 × 2 = 0 + 0.000 000 072 499 047 956 48;
  • 36) 0.000 000 072 499 047 956 48 × 2 = 0 + 0.000 000 144 998 095 912 96;
  • 37) 0.000 000 144 998 095 912 96 × 2 = 0 + 0.000 000 289 996 191 825 92;
  • 38) 0.000 000 289 996 191 825 92 × 2 = 0 + 0.000 000 579 992 383 651 84;
  • 39) 0.000 000 579 992 383 651 84 × 2 = 0 + 0.000 001 159 984 767 303 68;
  • 40) 0.000 001 159 984 767 303 68 × 2 = 0 + 0.000 002 319 969 534 607 36;
  • 41) 0.000 002 319 969 534 607 36 × 2 = 0 + 0.000 004 639 939 069 214 72;
  • 42) 0.000 004 639 939 069 214 72 × 2 = 0 + 0.000 009 279 878 138 429 44;
  • 43) 0.000 009 279 878 138 429 44 × 2 = 0 + 0.000 018 559 756 276 858 88;
  • 44) 0.000 018 559 756 276 858 88 × 2 = 0 + 0.000 037 119 512 553 717 76;
  • 45) 0.000 037 119 512 553 717 76 × 2 = 0 + 0.000 074 239 025 107 435 52;
  • 46) 0.000 074 239 025 107 435 52 × 2 = 0 + 0.000 148 478 050 214 871 04;
  • 47) 0.000 148 478 050 214 871 04 × 2 = 0 + 0.000 296 956 100 429 742 08;
  • 48) 0.000 296 956 100 429 742 08 × 2 = 0 + 0.000 593 912 200 859 484 16;
  • 49) 0.000 593 912 200 859 484 16 × 2 = 0 + 0.001 187 824 401 718 968 32;
  • 50) 0.001 187 824 401 718 968 32 × 2 = 0 + 0.002 375 648 803 437 936 64;
  • 51) 0.002 375 648 803 437 936 64 × 2 = 0 + 0.004 751 297 606 875 873 28;
  • 52) 0.004 751 297 606 875 873 28 × 2 = 0 + 0.009 502 595 213 751 746 56;
  • 53) 0.009 502 595 213 751 746 56 × 2 = 0 + 0.019 005 190 427 503 493 12;
  • 54) 0.019 005 190 427 503 493 12 × 2 = 0 + 0.038 010 380 855 006 986 24;
  • 55) 0.038 010 380 855 006 986 24 × 2 = 0 + 0.076 020 761 710 013 972 48;
  • 56) 0.076 020 761 710 013 972 48 × 2 = 0 + 0.152 041 523 420 027 944 96;
  • 57) 0.152 041 523 420 027 944 96 × 2 = 0 + 0.304 083 046 840 055 889 92;
  • 58) 0.304 083 046 840 055 889 92 × 2 = 0 + 0.608 166 093 680 111 779 84;
  • 59) 0.608 166 093 680 111 779 84 × 2 = 1 + 0.216 332 187 360 223 559 68;
  • 60) 0.216 332 187 360 223 559 68 × 2 = 0 + 0.432 664 374 720 447 119 36;
  • 61) 0.432 664 374 720 447 119 36 × 2 = 0 + 0.865 328 749 440 894 238 72;
  • 62) 0.865 328 749 440 894 238 72 × 2 = 1 + 0.730 657 498 881 788 477 44;
  • 63) 0.730 657 498 881 788 477 44 × 2 = 1 + 0.461 314 997 763 576 954 88;
  • 64) 0.461 314 997 763 576 954 88 × 2 = 0 + 0.922 629 995 527 153 909 76;
  • 65) 0.922 629 995 527 153 909 76 × 2 = 1 + 0.845 259 991 054 307 819 52;
  • 66) 0.845 259 991 054 307 819 52 × 2 = 1 + 0.690 519 982 108 615 639 04;
  • 67) 0.690 519 982 108 615 639 04 × 2 = 1 + 0.381 039 964 217 231 278 08;
  • 68) 0.381 039 964 217 231 278 08 × 2 = 0 + 0.762 079 928 434 462 556 16;
  • 69) 0.762 079 928 434 462 556 16 × 2 = 1 + 0.524 159 856 868 925 112 32;
  • 70) 0.524 159 856 868 925 112 32 × 2 = 1 + 0.048 319 713 737 850 224 64;
  • 71) 0.048 319 713 737 850 224 64 × 2 = 0 + 0.096 639 427 475 700 449 28;
  • 72) 0.096 639 427 475 700 449 28 × 2 = 0 + 0.193 278 854 951 400 898 56;
  • 73) 0.193 278 854 951 400 898 56 × 2 = 0 + 0.386 557 709 902 801 797 12;
  • 74) 0.386 557 709 902 801 797 12 × 2 = 0 + 0.773 115 419 805 603 594 24;
  • 75) 0.773 115 419 805 603 594 24 × 2 = 1 + 0.546 230 839 611 207 188 48;
  • 76) 0.546 230 839 611 207 188 48 × 2 = 1 + 0.092 461 679 222 414 376 96;
  • 77) 0.092 461 679 222 414 376 96 × 2 = 0 + 0.184 923 358 444 828 753 92;
  • 78) 0.184 923 358 444 828 753 92 × 2 = 0 + 0.369 846 716 889 657 507 84;
  • 79) 0.369 846 716 889 657 507 84 × 2 = 0 + 0.739 693 433 779 315 015 68;
  • 80) 0.739 693 433 779 315 015 68 × 2 = 1 + 0.479 386 867 558 630 031 36;
  • 81) 0.479 386 867 558 630 031 36 × 2 = 0 + 0.958 773 735 117 260 062 72;
  • 82) 0.958 773 735 117 260 062 72 × 2 = 1 + 0.917 547 470 234 520 125 44;

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...)


5. 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 002 11(10) =

0.0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0010 0110 1110 1100 0011 0001 01(2)


6. Positive number before normalization:

0.000 000 000 000 000 002 11(10) =

0.0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0010 0110 1110 1100 0011 0001 01(2)

7. Normalize the binary representation of the number.

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


0.000 000 000 000 000 002 11(10) =

0.0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0010 0110 1110 1100 0011 0001 01(2) =

0.0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0010 0110 1110 1100 0011 0001 01(2) × 20 =

1.0011 0111 0110 0001 1000 101(2) × 2-59


8. 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 1 (a negative number)

Exponent (unadjusted): -59

Mantissa (not normalized):
1.0011 0111 0110 0001 1000 101


9. Adjust the exponent.

Use the 8 bit excess/bias notation:


Exponent (adjusted) =

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

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

(-59 + 127)(10) =

68(10)


10. 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;
  • 68 ÷ 2 = 34 + 0;
  • 34 ÷ 2 = 17 + 0;
  • 17 ÷ 2 = 8 + 1;
  • 8 ÷ 2 = 4 + 0;
  • 4 ÷ 2 = 2 + 0;
  • 2 ÷ 2 = 1 + 0;
  • 1 ÷ 2 = 0 + 1;

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

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


Exponent (adjusted) =

68(10) =

0100 0100(2)


12. 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. 001 1011 1011 0000 1100 0101 =

001 1011 1011 0000 1100 0101


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

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

Exponent (8 bits) =
0100 0100

Mantissa (23 bits) =
001 1011 1011 0000 1100 0101


The base ten decimal number -0.000 000 000 000 000 002 11 converted and written in 32 bit single precision IEEE 754 binary floating point representation:
1 - 0100 0100 - 001 1011 1011 0000 1100 0101

More operations with decimal numbers converted to 32 bit single precision IEEE 754 binary floating point representation:

» Number -0.000 000 000 000 000 002 12 converted from decimal system (base 10) to 32 bit single precision IEEE 754 binary floating point representation = ?

» Number -0.000 000 000 000 000 002 1 converted from decimal system (base 10) to 32 bit single precision IEEE 754 binary floating point representation = ?

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

Number 10 000 001 012 converted from decimal system (written in base ten) to 32 bit single precision IEEE 754 binary floating point representation standard May 18 17:07 UTC (GMT)
Number 44 360 940 converted from decimal system (written in base ten) to 32 bit single precision IEEE 754 binary floating point representation standard May 18 17:07 UTC (GMT)
Number 4 399 888 converted from decimal system (written in base ten) to 32 bit single precision IEEE 754 binary floating point representation standard May 18 17:07 UTC (GMT)
Number -2.651 01 converted from decimal system (written in base ten) to 32 bit single precision IEEE 754 binary floating point representation standard May 18 17:07 UTC (GMT)
Number 19 999.6 converted from decimal system (written in base ten) to 32 bit single precision IEEE 754 binary floating point representation standard May 18 17:07 UTC (GMT)
Number -9 211.6 converted from decimal system (written in base ten) to 32 bit single precision IEEE 754 binary floating point representation standard May 18 17:07 UTC (GMT)
Number 279.069 converted from decimal system (written in base ten) to 32 bit single precision IEEE 754 binary floating point representation standard May 18 17:07 UTC (GMT)
Number 48 416 converted from decimal system (written in base ten) to 32 bit single precision IEEE 754 binary floating point representation standard May 18 17:07 UTC (GMT)
Number -3.955 9 converted from decimal system (written in base ten) to 32 bit single precision IEEE 754 binary floating point representation standard May 18 17:07 UTC (GMT)
Number 6.073 converted from decimal system (written in base ten) to 32 bit single precision IEEE 754 binary floating point representation standard May 18 17:07 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