32bit IEEE 754: Decimal -> Single Precision Floating Point Binary: 10 000 111 111 101 101 110 010 110 971 Convert the Number to 32 Bit Single Precision IEEE 754 Binary Floating Point Representation Standard, From a Base 10 Decimal System Number

Number 10 000 111 111 101 101 110 010 110 971(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. 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;
  • 10 000 111 111 101 101 110 010 110 971 ÷ 2 = 5 000 055 555 550 550 555 005 055 485 + 1;
  • 5 000 055 555 550 550 555 005 055 485 ÷ 2 = 2 500 027 777 775 275 277 502 527 742 + 1;
  • 2 500 027 777 775 275 277 502 527 742 ÷ 2 = 1 250 013 888 887 637 638 751 263 871 + 0;
  • 1 250 013 888 887 637 638 751 263 871 ÷ 2 = 625 006 944 443 818 819 375 631 935 + 1;
  • 625 006 944 443 818 819 375 631 935 ÷ 2 = 312 503 472 221 909 409 687 815 967 + 1;
  • 312 503 472 221 909 409 687 815 967 ÷ 2 = 156 251 736 110 954 704 843 907 983 + 1;
  • 156 251 736 110 954 704 843 907 983 ÷ 2 = 78 125 868 055 477 352 421 953 991 + 1;
  • 78 125 868 055 477 352 421 953 991 ÷ 2 = 39 062 934 027 738 676 210 976 995 + 1;
  • 39 062 934 027 738 676 210 976 995 ÷ 2 = 19 531 467 013 869 338 105 488 497 + 1;
  • 19 531 467 013 869 338 105 488 497 ÷ 2 = 9 765 733 506 934 669 052 744 248 + 1;
  • 9 765 733 506 934 669 052 744 248 ÷ 2 = 4 882 866 753 467 334 526 372 124 + 0;
  • 4 882 866 753 467 334 526 372 124 ÷ 2 = 2 441 433 376 733 667 263 186 062 + 0;
  • 2 441 433 376 733 667 263 186 062 ÷ 2 = 1 220 716 688 366 833 631 593 031 + 0;
  • 1 220 716 688 366 833 631 593 031 ÷ 2 = 610 358 344 183 416 815 796 515 + 1;
  • 610 358 344 183 416 815 796 515 ÷ 2 = 305 179 172 091 708 407 898 257 + 1;
  • 305 179 172 091 708 407 898 257 ÷ 2 = 152 589 586 045 854 203 949 128 + 1;
  • 152 589 586 045 854 203 949 128 ÷ 2 = 76 294 793 022 927 101 974 564 + 0;
  • 76 294 793 022 927 101 974 564 ÷ 2 = 38 147 396 511 463 550 987 282 + 0;
  • 38 147 396 511 463 550 987 282 ÷ 2 = 19 073 698 255 731 775 493 641 + 0;
  • 19 073 698 255 731 775 493 641 ÷ 2 = 9 536 849 127 865 887 746 820 + 1;
  • 9 536 849 127 865 887 746 820 ÷ 2 = 4 768 424 563 932 943 873 410 + 0;
  • 4 768 424 563 932 943 873 410 ÷ 2 = 2 384 212 281 966 471 936 705 + 0;
  • 2 384 212 281 966 471 936 705 ÷ 2 = 1 192 106 140 983 235 968 352 + 1;
  • 1 192 106 140 983 235 968 352 ÷ 2 = 596 053 070 491 617 984 176 + 0;
  • 596 053 070 491 617 984 176 ÷ 2 = 298 026 535 245 808 992 088 + 0;
  • 298 026 535 245 808 992 088 ÷ 2 = 149 013 267 622 904 496 044 + 0;
  • 149 013 267 622 904 496 044 ÷ 2 = 74 506 633 811 452 248 022 + 0;
  • 74 506 633 811 452 248 022 ÷ 2 = 37 253 316 905 726 124 011 + 0;
  • 37 253 316 905 726 124 011 ÷ 2 = 18 626 658 452 863 062 005 + 1;
  • 18 626 658 452 863 062 005 ÷ 2 = 9 313 329 226 431 531 002 + 1;
  • 9 313 329 226 431 531 002 ÷ 2 = 4 656 664 613 215 765 501 + 0;
  • 4 656 664 613 215 765 501 ÷ 2 = 2 328 332 306 607 882 750 + 1;
  • 2 328 332 306 607 882 750 ÷ 2 = 1 164 166 153 303 941 375 + 0;
  • 1 164 166 153 303 941 375 ÷ 2 = 582 083 076 651 970 687 + 1;
  • 582 083 076 651 970 687 ÷ 2 = 291 041 538 325 985 343 + 1;
  • 291 041 538 325 985 343 ÷ 2 = 145 520 769 162 992 671 + 1;
  • 145 520 769 162 992 671 ÷ 2 = 72 760 384 581 496 335 + 1;
  • 72 760 384 581 496 335 ÷ 2 = 36 380 192 290 748 167 + 1;
  • 36 380 192 290 748 167 ÷ 2 = 18 190 096 145 374 083 + 1;
  • 18 190 096 145 374 083 ÷ 2 = 9 095 048 072 687 041 + 1;
  • 9 095 048 072 687 041 ÷ 2 = 4 547 524 036 343 520 + 1;
  • 4 547 524 036 343 520 ÷ 2 = 2 273 762 018 171 760 + 0;
  • 2 273 762 018 171 760 ÷ 2 = 1 136 881 009 085 880 + 0;
  • 1 136 881 009 085 880 ÷ 2 = 568 440 504 542 940 + 0;
  • 568 440 504 542 940 ÷ 2 = 284 220 252 271 470 + 0;
  • 284 220 252 271 470 ÷ 2 = 142 110 126 135 735 + 0;
  • 142 110 126 135 735 ÷ 2 = 71 055 063 067 867 + 1;
  • 71 055 063 067 867 ÷ 2 = 35 527 531 533 933 + 1;
  • 35 527 531 533 933 ÷ 2 = 17 763 765 766 966 + 1;
  • 17 763 765 766 966 ÷ 2 = 8 881 882 883 483 + 0;
  • 8 881 882 883 483 ÷ 2 = 4 440 941 441 741 + 1;
  • 4 440 941 441 741 ÷ 2 = 2 220 470 720 870 + 1;
  • 2 220 470 720 870 ÷ 2 = 1 110 235 360 435 + 0;
  • 1 110 235 360 435 ÷ 2 = 555 117 680 217 + 1;
  • 555 117 680 217 ÷ 2 = 277 558 840 108 + 1;
  • 277 558 840 108 ÷ 2 = 138 779 420 054 + 0;
  • 138 779 420 054 ÷ 2 = 69 389 710 027 + 0;
  • 69 389 710 027 ÷ 2 = 34 694 855 013 + 1;
  • 34 694 855 013 ÷ 2 = 17 347 427 506 + 1;
  • 17 347 427 506 ÷ 2 = 8 673 713 753 + 0;
  • 8 673 713 753 ÷ 2 = 4 336 856 876 + 1;
  • 4 336 856 876 ÷ 2 = 2 168 428 438 + 0;
  • 2 168 428 438 ÷ 2 = 1 084 214 219 + 0;
  • 1 084 214 219 ÷ 2 = 542 107 109 + 1;
  • 542 107 109 ÷ 2 = 271 053 554 + 1;
  • 271 053 554 ÷ 2 = 135 526 777 + 0;
  • 135 526 777 ÷ 2 = 67 763 388 + 1;
  • 67 763 388 ÷ 2 = 33 881 694 + 0;
  • 33 881 694 ÷ 2 = 16 940 847 + 0;
  • 16 940 847 ÷ 2 = 8 470 423 + 1;
  • 8 470 423 ÷ 2 = 4 235 211 + 1;
  • 4 235 211 ÷ 2 = 2 117 605 + 1;
  • 2 117 605 ÷ 2 = 1 058 802 + 1;
  • 1 058 802 ÷ 2 = 529 401 + 0;
  • 529 401 ÷ 2 = 264 700 + 1;
  • 264 700 ÷ 2 = 132 350 + 0;
  • 132 350 ÷ 2 = 66 175 + 0;
  • 66 175 ÷ 2 = 33 087 + 1;
  • 33 087 ÷ 2 = 16 543 + 1;
  • 16 543 ÷ 2 = 8 271 + 1;
  • 8 271 ÷ 2 = 4 135 + 1;
  • 4 135 ÷ 2 = 2 067 + 1;
  • 2 067 ÷ 2 = 1 033 + 1;
  • 1 033 ÷ 2 = 516 + 1;
  • 516 ÷ 2 = 258 + 0;
  • 258 ÷ 2 = 129 + 0;
  • 129 ÷ 2 = 64 + 1;
  • 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;

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

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


10 000 111 111 101 101 110 010 110 971(10) =


10 0000 0100 1111 1110 0101 1110 0101 1001 0110 0110 1101 1100 0001 1111 1110 1011 0000 0100 1000 1110 0011 1111 1011(2)


3. Normalize the binary representation of the number.

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


10 000 111 111 101 101 110 010 110 971(10) =


10 0000 0100 1111 1110 0101 1110 0101 1001 0110 0110 1101 1100 0001 1111 1110 1011 0000 0100 1000 1110 0011 1111 1011(2) =


10 0000 0100 1111 1110 0101 1110 0101 1001 0110 0110 1101 1100 0001 1111 1110 1011 0000 0100 1000 1110 0011 1111 1011(2) × 20 =


1.0000 0010 0111 1111 0010 1111 0010 1100 1011 0011 0110 1110 0000 1111 1111 0101 1000 0010 0100 0111 0001 1111 1101 1(2) × 293


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


Mantissa (not normalized):
1.0000 0010 0111 1111 0010 1111 0010 1100 1011 0011 0110 1110 0000 1111 1111 0101 1000 0010 0100 0111 0001 1111 1101 1


5. Adjust the exponent.

Use the 8 bit excess/bias notation:


Exponent (adjusted) =


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


93 + 2(8-1) - 1 =


(93 + 127)(10) =


220(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;
  • 220 ÷ 2 = 110 + 0;
  • 110 ÷ 2 = 55 + 0;
  • 55 ÷ 2 = 27 + 1;
  • 27 ÷ 2 = 13 + 1;
  • 13 ÷ 2 = 6 + 1;
  • 6 ÷ 2 = 3 + 0;
  • 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) =


220(10) =


1101 1100(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. 000 0001 0011 1111 1001 0111 10 0101 1001 0110 0110 1101 1100 0001 1111 1110 1011 0000 0100 1000 1110 0011 1111 1011 =


000 0001 0011 1111 1001 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) =
1101 1100


Mantissa (23 bits) =
000 0001 0011 1111 1001 0111


The base ten decimal number 10 000 111 111 101 101 110 010 110 971 converted and written in 32 bit single precision IEEE 754 binary floating point representation:
0 - 1101 1100 - 000 0001 0011 1111 1001 0111

(32 bits IEEE 754)
  • Sign (1 bit):

    • 0

      31
  • Exponent (8 bits):

    • 1

      30
    • 1

      29
    • 0

      28
    • 1

      27
    • 1

      26
    • 1

      25
    • 0

      24
    • 0

      23
  • Mantissa (23 bits):

    • 0

      22
    • 0

      21
    • 0

      20
    • 0

      19
    • 0

      18
    • 0

      17
    • 1

      16
    • 0

      15
    • 0

      14
    • 1

      13
    • 1

      12
    • 1

      11
    • 1

      10
    • 1

      9
    • 1

      8
    • 1

      7
    • 0

      6
    • 0

      5
    • 1

      4
    • 0

      3
    • 1

      2
    • 1

      1
    • 1

      0

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

Number 10 000 111 111 101 101 110 010 110 971 converted from decimal system (written in base ten) to 32 bit single precision IEEE 754 binary floating point representation standard Feb 27 03:01 UTC (GMT)
Number 111 101 002 converted from decimal system (written in base ten) to 32 bit single precision IEEE 754 binary floating point representation standard Feb 27 03:01 UTC (GMT)
Number 110 001 011 110 160 converted from decimal system (written in base ten) to 32 bit single precision IEEE 754 binary floating point representation standard Feb 27 03:01 UTC (GMT)
Number 2 147 483 647 324 converted from decimal system (written in base ten) to 32 bit single precision IEEE 754 binary floating point representation standard Feb 27 03:01 UTC (GMT)
Number 5.070 6 converted from decimal system (written in base ten) to 32 bit single precision IEEE 754 binary floating point representation standard Feb 27 03:01 UTC (GMT)
Number 3 221 225 569 converted from decimal system (written in base ten) to 32 bit single precision IEEE 754 binary floating point representation standard Feb 27 03:01 UTC (GMT)
Number 21 890 791 converted from decimal system (written in base ten) to 32 bit single precision IEEE 754 binary floating point representation standard Feb 27 03:01 UTC (GMT)
Number 74 999 897 converted from decimal system (written in base ten) to 32 bit single precision IEEE 754 binary floating point representation standard Feb 27 03:01 UTC (GMT)
Number -912.5 converted from decimal system (written in base ten) to 32 bit single precision IEEE 754 binary floating point representation standard Feb 27 03:01 UTC (GMT)
Number 2 258 024 679 928 converted from decimal system (written in base ten) to 32 bit single precision IEEE 754 binary floating point representation standard Feb 27 03:01 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