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

Number -0.398 46(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.398 46| = 0.398 46

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.398 46.

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.398 46 × 2 = 0 + 0.796 92;
  • 2) 0.796 92 × 2 = 1 + 0.593 84;
  • 3) 0.593 84 × 2 = 1 + 0.187 68;
  • 4) 0.187 68 × 2 = 0 + 0.375 36;
  • 5) 0.375 36 × 2 = 0 + 0.750 72;
  • 6) 0.750 72 × 2 = 1 + 0.501 44;
  • 7) 0.501 44 × 2 = 1 + 0.002 88;
  • 8) 0.002 88 × 2 = 0 + 0.005 76;
  • 9) 0.005 76 × 2 = 0 + 0.011 52;
  • 10) 0.011 52 × 2 = 0 + 0.023 04;
  • 11) 0.023 04 × 2 = 0 + 0.046 08;
  • 12) 0.046 08 × 2 = 0 + 0.092 16;
  • 13) 0.092 16 × 2 = 0 + 0.184 32;
  • 14) 0.184 32 × 2 = 0 + 0.368 64;
  • 15) 0.368 64 × 2 = 0 + 0.737 28;
  • 16) 0.737 28 × 2 = 1 + 0.474 56;
  • 17) 0.474 56 × 2 = 0 + 0.949 12;
  • 18) 0.949 12 × 2 = 1 + 0.898 24;
  • 19) 0.898 24 × 2 = 1 + 0.796 48;
  • 20) 0.796 48 × 2 = 1 + 0.592 96;
  • 21) 0.592 96 × 2 = 1 + 0.185 92;
  • 22) 0.185 92 × 2 = 0 + 0.371 84;
  • 23) 0.371 84 × 2 = 0 + 0.743 68;
  • 24) 0.743 68 × 2 = 1 + 0.487 36;
  • 25) 0.487 36 × 2 = 0 + 0.974 72;

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.398 46(10) =


0.0110 0110 0000 0001 0111 1001 0(2)


6. Positive number before normalization:

0.398 46(10) =


0.0110 0110 0000 0001 0111 1001 0(2)

7. Normalize the binary representation of the number.

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


0.398 46(10) =


0.0110 0110 0000 0001 0111 1001 0(2) =


0.0110 0110 0000 0001 0111 1001 0(2) × 20 =


1.1001 1000 0000 0101 1110 010(2) × 2-2


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


Mantissa (not normalized):
1.1001 1000 0000 0101 1110 010


9. Adjust the exponent.

Use the 8 bit excess/bias notation:


Exponent (adjusted) =


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


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


(-2 + 127)(10) =


125(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;
  • 125 ÷ 2 = 62 + 1;
  • 62 ÷ 2 = 31 + 0;
  • 31 ÷ 2 = 15 + 1;
  • 15 ÷ 2 = 7 + 1;
  • 7 ÷ 2 = 3 + 1;
  • 3 ÷ 2 = 1 + 1;
  • 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) =


125(10) =


0111 1101(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. 100 1100 0000 0010 1111 0010 =


100 1100 0000 0010 1111 0010


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


Mantissa (23 bits) =
100 1100 0000 0010 1111 0010


The base ten decimal number -0.398 46 converted and written in 32 bit single precision IEEE 754 binary floating point representation:
1 - 0111 1101 - 100 1100 0000 0010 1111 0010

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