0.000 000 000 050 403 024 8 Converted to 32 Bit Single Precision IEEE 754 Binary Floating Point Representation Standard

Convert decimal 0.000 000 000 050 403 024 8(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 050 403 024 8(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 050 403 024 8.

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 050 403 024 8 × 2 = 0 + 0.000 000 000 100 806 049 6;
  • 2) 0.000 000 000 100 806 049 6 × 2 = 0 + 0.000 000 000 201 612 099 2;
  • 3) 0.000 000 000 201 612 099 2 × 2 = 0 + 0.000 000 000 403 224 198 4;
  • 4) 0.000 000 000 403 224 198 4 × 2 = 0 + 0.000 000 000 806 448 396 8;
  • 5) 0.000 000 000 806 448 396 8 × 2 = 0 + 0.000 000 001 612 896 793 6;
  • 6) 0.000 000 001 612 896 793 6 × 2 = 0 + 0.000 000 003 225 793 587 2;
  • 7) 0.000 000 003 225 793 587 2 × 2 = 0 + 0.000 000 006 451 587 174 4;
  • 8) 0.000 000 006 451 587 174 4 × 2 = 0 + 0.000 000 012 903 174 348 8;
  • 9) 0.000 000 012 903 174 348 8 × 2 = 0 + 0.000 000 025 806 348 697 6;
  • 10) 0.000 000 025 806 348 697 6 × 2 = 0 + 0.000 000 051 612 697 395 2;
  • 11) 0.000 000 051 612 697 395 2 × 2 = 0 + 0.000 000 103 225 394 790 4;
  • 12) 0.000 000 103 225 394 790 4 × 2 = 0 + 0.000 000 206 450 789 580 8;
  • 13) 0.000 000 206 450 789 580 8 × 2 = 0 + 0.000 000 412 901 579 161 6;
  • 14) 0.000 000 412 901 579 161 6 × 2 = 0 + 0.000 000 825 803 158 323 2;
  • 15) 0.000 000 825 803 158 323 2 × 2 = 0 + 0.000 001 651 606 316 646 4;
  • 16) 0.000 001 651 606 316 646 4 × 2 = 0 + 0.000 003 303 212 633 292 8;
  • 17) 0.000 003 303 212 633 292 8 × 2 = 0 + 0.000 006 606 425 266 585 6;
  • 18) 0.000 006 606 425 266 585 6 × 2 = 0 + 0.000 013 212 850 533 171 2;
  • 19) 0.000 013 212 850 533 171 2 × 2 = 0 + 0.000 026 425 701 066 342 4;
  • 20) 0.000 026 425 701 066 342 4 × 2 = 0 + 0.000 052 851 402 132 684 8;
  • 21) 0.000 052 851 402 132 684 8 × 2 = 0 + 0.000 105 702 804 265 369 6;
  • 22) 0.000 105 702 804 265 369 6 × 2 = 0 + 0.000 211 405 608 530 739 2;
  • 23) 0.000 211 405 608 530 739 2 × 2 = 0 + 0.000 422 811 217 061 478 4;
  • 24) 0.000 422 811 217 061 478 4 × 2 = 0 + 0.000 845 622 434 122 956 8;
  • 25) 0.000 845 622 434 122 956 8 × 2 = 0 + 0.001 691 244 868 245 913 6;
  • 26) 0.001 691 244 868 245 913 6 × 2 = 0 + 0.003 382 489 736 491 827 2;
  • 27) 0.003 382 489 736 491 827 2 × 2 = 0 + 0.006 764 979 472 983 654 4;
  • 28) 0.006 764 979 472 983 654 4 × 2 = 0 + 0.013 529 958 945 967 308 8;
  • 29) 0.013 529 958 945 967 308 8 × 2 = 0 + 0.027 059 917 891 934 617 6;
  • 30) 0.027 059 917 891 934 617 6 × 2 = 0 + 0.054 119 835 783 869 235 2;
  • 31) 0.054 119 835 783 869 235 2 × 2 = 0 + 0.108 239 671 567 738 470 4;
  • 32) 0.108 239 671 567 738 470 4 × 2 = 0 + 0.216 479 343 135 476 940 8;
  • 33) 0.216 479 343 135 476 940 8 × 2 = 0 + 0.432 958 686 270 953 881 6;
  • 34) 0.432 958 686 270 953 881 6 × 2 = 0 + 0.865 917 372 541 907 763 2;
  • 35) 0.865 917 372 541 907 763 2 × 2 = 1 + 0.731 834 745 083 815 526 4;
  • 36) 0.731 834 745 083 815 526 4 × 2 = 1 + 0.463 669 490 167 631 052 8;
  • 37) 0.463 669 490 167 631 052 8 × 2 = 0 + 0.927 338 980 335 262 105 6;
  • 38) 0.927 338 980 335 262 105 6 × 2 = 1 + 0.854 677 960 670 524 211 2;
  • 39) 0.854 677 960 670 524 211 2 × 2 = 1 + 0.709 355 921 341 048 422 4;
  • 40) 0.709 355 921 341 048 422 4 × 2 = 1 + 0.418 711 842 682 096 844 8;
  • 41) 0.418 711 842 682 096 844 8 × 2 = 0 + 0.837 423 685 364 193 689 6;
  • 42) 0.837 423 685 364 193 689 6 × 2 = 1 + 0.674 847 370 728 387 379 2;
  • 43) 0.674 847 370 728 387 379 2 × 2 = 1 + 0.349 694 741 456 774 758 4;
  • 44) 0.349 694 741 456 774 758 4 × 2 = 0 + 0.699 389 482 913 549 516 8;
  • 45) 0.699 389 482 913 549 516 8 × 2 = 1 + 0.398 778 965 827 099 033 6;
  • 46) 0.398 778 965 827 099 033 6 × 2 = 0 + 0.797 557 931 654 198 067 2;
  • 47) 0.797 557 931 654 198 067 2 × 2 = 1 + 0.595 115 863 308 396 134 4;
  • 48) 0.595 115 863 308 396 134 4 × 2 = 1 + 0.190 231 726 616 792 268 8;
  • 49) 0.190 231 726 616 792 268 8 × 2 = 0 + 0.380 463 453 233 584 537 6;
  • 50) 0.380 463 453 233 584 537 6 × 2 = 0 + 0.760 926 906 467 169 075 2;
  • 51) 0.760 926 906 467 169 075 2 × 2 = 1 + 0.521 853 812 934 338 150 4;
  • 52) 0.521 853 812 934 338 150 4 × 2 = 1 + 0.043 707 625 868 676 300 8;
  • 53) 0.043 707 625 868 676 300 8 × 2 = 0 + 0.087 415 251 737 352 601 6;
  • 54) 0.087 415 251 737 352 601 6 × 2 = 0 + 0.174 830 503 474 705 203 2;
  • 55) 0.174 830 503 474 705 203 2 × 2 = 0 + 0.349 661 006 949 410 406 4;
  • 56) 0.349 661 006 949 410 406 4 × 2 = 0 + 0.699 322 013 898 820 812 8;
  • 57) 0.699 322 013 898 820 812 8 × 2 = 1 + 0.398 644 027 797 641 625 6;
  • 58) 0.398 644 027 797 641 625 6 × 2 = 0 + 0.797 288 055 595 283 251 2;

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 050 403 024 8(10) =

0.0000 0000 0000 0000 0000 0000 0000 0000 0011 0111 0110 1011 0011 0000 10(2)

5. Positive number before normalization:

0.000 000 000 050 403 024 8(10) =

0.0000 0000 0000 0000 0000 0000 0000 0000 0011 0111 0110 1011 0011 0000 10(2)

6. Normalize the binary representation of the number.

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


0.000 000 000 050 403 024 8(10) =

0.0000 0000 0000 0000 0000 0000 0000 0000 0011 0111 0110 1011 0011 0000 10(2) =

0.0000 0000 0000 0000 0000 0000 0000 0000 0011 0111 0110 1011 0011 0000 10(2) × 20 =

1.1011 1011 0101 1001 1000 010(2) × 2-35


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

Mantissa (not normalized):
1.1011 1011 0101 1001 1000 010


8. Adjust the exponent.

Use the 8 bit excess/bias notation:


Exponent (adjusted) =

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

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

(-35 + 127)(10) =

92(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;
  • 92 ÷ 2 = 46 + 0;
  • 46 ÷ 2 = 23 + 0;
  • 23 ÷ 2 = 11 + 1;
  • 11 ÷ 2 = 5 + 1;
  • 5 ÷ 2 = 2 + 1;
  • 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) =

92(10) =

0101 1100(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 1101 1010 1100 1100 0010 =

101 1101 1010 1100 1100 0010


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) =
0101 1100

Mantissa (23 bits) =
101 1101 1010 1100 1100 0010


Decimal number 0.000 000 000 050 403 024 8 converted to 32 bit single precision IEEE 754 binary floating point representation:

0 - 0101 1100 - 101 1101 1010 1100 1100 0010

» Convert decimal 0.000 000 000 050 403 034 6 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 10, 2026 [October]: Decimal Numbers Converted to 32 Bit Single Precision IEEE 754 Binary Floating Point Representation Standard. Calculations performed during the month of: October - by our visitors

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