CODEWITHSUNDEEP
doublebit-manipulationpointfloating
NotSure
NotSure

Reputation: 681

Calculating floating points as binary

The question is : x and y are two floating point numbers in 32-bit IEEE floating-point format (8-bit exponent with bias 127) whose binary representation is as follows:

x: 1 10000001 00010100000000000000000

y: 0 10000010 00100001000000000000000

Compute their product z = x y and give the result in binary IEEE floating-point format.

So I've found out that X = -4.3125. y = 9.03125. i can multiply them and get -38.947265625. I don't know how to show it in a IEEE format. Thanks in advance for the help.

Upvotes: 0

Views: 107

Answers (2)

Patricia Shanahan
Patricia Shanahan

Reputation: 26185

I agree with the comment that it should be done in binary, rather than by conversion to decimal and decimal multiplication. I used Exploring Binary to do the arithmetic.

The first step is to find the actual binary significands. Neither input is subnormal, so they are 1.000101 and 1.00100001.

Multiply them, getting 1.00110111100101.

Similarly, subtract the bias, binary 1111111, from the exponents, getting 10 and 11. Add those, getting 101, then add back the bias, 10000100.

The sign bit for multiplying two numbers with different sign bits will be 1.

Now pack it all back together. The signficand came out in the [1,2) range so there is no need to normalize and adjust the exponent. We are still in the normal range, so drop the 1 before the binary point in the significand. The significand is narrow enough to fit without rounding - just add enough trailing zeros.

1 10000100 00110111100101000000000

Upvotes: 1

user555045
user555045

Reputation: 64904

You've made it harder by converting to decimal, the way you'd have to convert it back. It's not that it can't be done that way, but it's harder by hand.

Without converting, the algorithm to multiply two floats is (roughly) this:

  • put the implicit 1 back (if applicable)
  • multiply, to full size (don't truncate) (you can get away with using just Guard and Sticky, if you know how they work)
  • add the exponents
  • xor the signs
  • normalize/round/handle special cases (under-/overflow)

So here, multiply (look up how binary multiply worked if you forgot) 

1.00010100000000000000000 *
1.00100001000000000000000 =

1.00100001000000000000000       +
0.000100100001000000000000000   +
0.00000100100001000000000000000 =

1.00110111100101000000000000000

Add exponents (mind the bias), 2+3 = 5 in this case, so 132 = 10000100.

Xor the signs, get 1.

No rounding is necessary because the dropped bits are all zero anyway.

Result: 1 10000100 00110111100101000000000

Upvotes: 1

Related Questions