32bit IEEE 754: Decimal ↗ Single Precision Floating Point Binary: 0.010 000 000 000 000 000 208 166 817 117 216 851 329 430 9 Convert the Number to 32 Bit Single Precision IEEE 754 Binary Floating Point Representation Standard, From a Base 10 Decimal System Number

Number 0.010 000 000 000 000 000 208 166 817 117 216 851 329 430 9(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. 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.010 000 000 000 000 000 208 166 817 117 216 851 329 430 9.

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.010 000 000 000 000 000 208 166 817 117 216 851 329 430 9 × 2 = 0 + 0.020 000 000 000 000 000 416 333 634 234 433 702 658 861 8;
  • 2) 0.020 000 000 000 000 000 416 333 634 234 433 702 658 861 8 × 2 = 0 + 0.040 000 000 000 000 000 832 667 268 468 867 405 317 723 6;
  • 3) 0.040 000 000 000 000 000 832 667 268 468 867 405 317 723 6 × 2 = 0 + 0.080 000 000 000 000 001 665 334 536 937 734 810 635 447 2;
  • 4) 0.080 000 000 000 000 001 665 334 536 937 734 810 635 447 2 × 2 = 0 + 0.160 000 000 000 000 003 330 669 073 875 469 621 270 894 4;
  • 5) 0.160 000 000 000 000 003 330 669 073 875 469 621 270 894 4 × 2 = 0 + 0.320 000 000 000 000 006 661 338 147 750 939 242 541 788 8;
  • 6) 0.320 000 000 000 000 006 661 338 147 750 939 242 541 788 8 × 2 = 0 + 0.640 000 000 000 000 013 322 676 295 501 878 485 083 577 6;
  • 7) 0.640 000 000 000 000 013 322 676 295 501 878 485 083 577 6 × 2 = 1 + 0.280 000 000 000 000 026 645 352 591 003 756 970 167 155 2;
  • 8) 0.280 000 000 000 000 026 645 352 591 003 756 970 167 155 2 × 2 = 0 + 0.560 000 000 000 000 053 290 705 182 007 513 940 334 310 4;
  • 9) 0.560 000 000 000 000 053 290 705 182 007 513 940 334 310 4 × 2 = 1 + 0.120 000 000 000 000 106 581 410 364 015 027 880 668 620 8;
  • 10) 0.120 000 000 000 000 106 581 410 364 015 027 880 668 620 8 × 2 = 0 + 0.240 000 000 000 000 213 162 820 728 030 055 761 337 241 6;
  • 11) 0.240 000 000 000 000 213 162 820 728 030 055 761 337 241 6 × 2 = 0 + 0.480 000 000 000 000 426 325 641 456 060 111 522 674 483 2;
  • 12) 0.480 000 000 000 000 426 325 641 456 060 111 522 674 483 2 × 2 = 0 + 0.960 000 000 000 000 852 651 282 912 120 223 045 348 966 4;
  • 13) 0.960 000 000 000 000 852 651 282 912 120 223 045 348 966 4 × 2 = 1 + 0.920 000 000 000 001 705 302 565 824 240 446 090 697 932 8;
  • 14) 0.920 000 000 000 001 705 302 565 824 240 446 090 697 932 8 × 2 = 1 + 0.840 000 000 000 003 410 605 131 648 480 892 181 395 865 6;
  • 15) 0.840 000 000 000 003 410 605 131 648 480 892 181 395 865 6 × 2 = 1 + 0.680 000 000 000 006 821 210 263 296 961 784 362 791 731 2;
  • 16) 0.680 000 000 000 006 821 210 263 296 961 784 362 791 731 2 × 2 = 1 + 0.360 000 000 000 013 642 420 526 593 923 568 725 583 462 4;
  • 17) 0.360 000 000 000 013 642 420 526 593 923 568 725 583 462 4 × 2 = 0 + 0.720 000 000 000 027 284 841 053 187 847 137 451 166 924 8;
  • 18) 0.720 000 000 000 027 284 841 053 187 847 137 451 166 924 8 × 2 = 1 + 0.440 000 000 000 054 569 682 106 375 694 274 902 333 849 6;
  • 19) 0.440 000 000 000 054 569 682 106 375 694 274 902 333 849 6 × 2 = 0 + 0.880 000 000 000 109 139 364 212 751 388 549 804 667 699 2;
  • 20) 0.880 000 000 000 109 139 364 212 751 388 549 804 667 699 2 × 2 = 1 + 0.760 000 000 000 218 278 728 425 502 777 099 609 335 398 4;
  • 21) 0.760 000 000 000 218 278 728 425 502 777 099 609 335 398 4 × 2 = 1 + 0.520 000 000 000 436 557 456 851 005 554 199 218 670 796 8;
  • 22) 0.520 000 000 000 436 557 456 851 005 554 199 218 670 796 8 × 2 = 1 + 0.040 000 000 000 873 114 913 702 011 108 398 437 341 593 6;
  • 23) 0.040 000 000 000 873 114 913 702 011 108 398 437 341 593 6 × 2 = 0 + 0.080 000 000 001 746 229 827 404 022 216 796 874 683 187 2;
  • 24) 0.080 000 000 001 746 229 827 404 022 216 796 874 683 187 2 × 2 = 0 + 0.160 000 000 003 492 459 654 808 044 433 593 749 366 374 4;
  • 25) 0.160 000 000 003 492 459 654 808 044 433 593 749 366 374 4 × 2 = 0 + 0.320 000 000 006 984 919 309 616 088 867 187 498 732 748 8;
  • 26) 0.320 000 000 006 984 919 309 616 088 867 187 498 732 748 8 × 2 = 0 + 0.640 000 000 013 969 838 619 232 177 734 374 997 465 497 6;
  • 27) 0.640 000 000 013 969 838 619 232 177 734 374 997 465 497 6 × 2 = 1 + 0.280 000 000 027 939 677 238 464 355 468 749 994 930 995 2;
  • 28) 0.280 000 000 027 939 677 238 464 355 468 749 994 930 995 2 × 2 = 0 + 0.560 000 000 055 879 354 476 928 710 937 499 989 861 990 4;
  • 29) 0.560 000 000 055 879 354 476 928 710 937 499 989 861 990 4 × 2 = 1 + 0.120 000 000 111 758 708 953 857 421 874 999 979 723 980 8;
  • 30) 0.120 000 000 111 758 708 953 857 421 874 999 979 723 980 8 × 2 = 0 + 0.240 000 000 223 517 417 907 714 843 749 999 959 447 961 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...)


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.010 000 000 000 000 000 208 166 817 117 216 851 329 430 9(10) =

0.0000 0010 1000 1111 0101 1100 0010 10(2)


5. Positive number before normalization:

0.010 000 000 000 000 000 208 166 817 117 216 851 329 430 9(10) =

0.0000 0010 1000 1111 0101 1100 0010 10(2)

6. Normalize the binary representation of the number.

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


0.010 000 000 000 000 000 208 166 817 117 216 851 329 430 9(10) =

0.0000 0010 1000 1111 0101 1100 0010 10(2) =

0.0000 0010 1000 1111 0101 1100 0010 10(2) × 20 =

1.0100 0111 1010 1110 0001 010(2) × 2-7


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

Mantissa (not normalized):
1.0100 0111 1010 1110 0001 010


8. Adjust the exponent.

Use the 8 bit excess/bias notation:


Exponent (adjusted) =

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

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

(-7 + 127)(10) =

120(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;
  • 120 ÷ 2 = 60 + 0;
  • 60 ÷ 2 = 30 + 0;
  • 30 ÷ 2 = 15 + 0;
  • 15 ÷ 2 = 7 + 1;
  • 7 ÷ 2 = 3 + 1;
  • 3 ÷ 2 = 1 + 1;
  • 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) =

120(10) =

0111 1000(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. 010 0011 1101 0111 0000 1010 =

010 0011 1101 0111 0000 1010


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) =
0111 1000

Mantissa (23 bits) =
010 0011 1101 0111 0000 1010


The base ten decimal number 0.010 000 000 000 000 000 208 166 817 117 216 851 329 430 9 converted and written in 32 bit single precision IEEE 754 binary floating point representation:
0 - 0111 1000 - 010 0011 1101 0111 0000 1010

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

» Number 0.010 000 000 000 000 000 208 166 817 117 216 851 329 430 8 converted from decimal system (base 10) to 32 bit single precision IEEE 754 binary floating point representation = ?

» Number 0.010 000 000 000 000 000 208 166 817 117 216 851 329 431 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 3 649 229 converted from decimal system (written in base ten) to 32 bit single precision IEEE 754 binary floating point representation standard Apr 30 09:21 UTC (GMT)
Number 376 932 converted from decimal system (written in base ten) to 32 bit single precision IEEE 754 binary floating point representation standard Apr 30 09:21 UTC (GMT)
Number 254.1 converted from decimal system (written in base ten) to 32 bit single precision IEEE 754 binary floating point representation standard Apr 30 09:21 UTC (GMT)
Number 73.877 converted from decimal system (written in base ten) to 32 bit single precision IEEE 754 binary floating point representation standard Apr 30 09:21 UTC (GMT)
Number 20 971 522 converted from decimal system (written in base ten) to 32 bit single precision IEEE 754 binary floating point representation standard Apr 30 09:21 UTC (GMT)
Number 777.25 converted from decimal system (written in base ten) to 32 bit single precision IEEE 754 binary floating point representation standard Apr 30 09:21 UTC (GMT)
Number -954.189 converted from decimal system (written in base ten) to 32 bit single precision IEEE 754 binary floating point representation standard Apr 30 09:21 UTC (GMT)
Number 42 351 035 converted from decimal system (written in base ten) to 32 bit single precision IEEE 754 binary floating point representation standard Apr 30 09:21 UTC (GMT)
Number 438.21 converted from decimal system (written in base ten) to 32 bit single precision IEEE 754 binary floating point representation standard Apr 30 09:21 UTC (GMT)
Number 24.13 converted from decimal system (written in base ten) to 32 bit single precision IEEE 754 binary floating point representation standard Apr 30 09:21 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