Bitwise multiplication of a floating point number

Question

I am working on a project for school that requires me to manipulate floating point numbers using only their binary representation, specifically multiplying a float by two. I am supposed to replicate the function of the following code using only bit operations (! | ^ & ~), logical operators (&&, ||), and if/while expressions.

However, I am having a problem with some of my numbers not having the correct result. For example, when I pass in 8388608 (0x800000), the output is 8388608 when it should be 16777216 (0x1000000).

Here is the code whose function we are supposed to replicate:

unsigned test_dl23(unsigned uf) {
float f = u2f(uf);
float tf = 2*f;
if (isnan(f))
  return uf;
else
  return f2u(tf);
}

And here is my attempt:

unsigned dl23(unsigned uf) {

int pullExpMask, expMask, mantMask, i, mask, signedBit
mask = 0x007fffff;

pullExpMask = (-1 << 23) ^ 0x80000000; // fills lower 23 bits with zeroes
signedBit = 0x80000000 & uf;
expMask = (uf & pullExpMask); // grabs the exponent and signed bits, mantissa bits are zeroes
mantMask = mask & uf;

if (!(uf & mask)){ // if uf has an exponent that is all ones, return uf
    return uf;
}

else if (expMask == 0){
   mantMask =  mantMask << 1;

} 
else if (expMask != 0){
  expMask = expMask + 0x00100000;
}

return (signedBit | expMask | mantMask);


}

I have been working on this problem for a long time, and any helpful tips would be greatly appreciated!

The mantissa is normalized, which means it has no leading '1' bit. Are you aware? — Nayuki, Jul 16 '16 at 03:23
I am aware that the leading 1 is implied, would that make a difference here? — diaga, Jul 16 '16 at 03:28
I wouldn't mix `unsigned` and `int`, that's just asking for trouble. — Mark Ransom, Jul 16 '16 at 03:42
You should put together a [minimal, complete, and verifiable example](https://stackoverflow.com/help/mcve). And while you're at it, change some of the names: uf, u2f, tf, f2u, f. Those names might mean something to you, but to everyone else, it just looks like a bunch of cursing and cussing. — user3386109, Jul 16 '16 at 04:31
[Converting float to an int (float2int) using only bitwise manipulation](http://stackoverflow.com/q/20318911/2410359) may be useful. — chux - Reinstate Monica, Jul 16 '16 at 05:42
To multiply a float by 2, simply increment the exponent field by 1. Don't need to touch the mantissa at all — Nayuki, Jul 16 '16 at 06:24
@Nayuki: well that is true, except for denormals and special values. — Rudy Velthuis, Jul 16 '16 at 09:39

robot1208 · Answer 1 · 2016-07-16T13:02:14.490

0

I'm not sure about what numbers you are referring to as failing, but I do see a bug in your code that would cause this behavior. The section with the comment // if uf has an exponent that is all ones, return uf does not do what this describes. It will test that the mantissa part is 0 and return the unchanged number, causing the behavior you're seeing. It should probably be something like if (expMask == pullExpMask) {

Also, you need to consider the case that the exponent increment makes it all 1. It should always become an inf, and never a quiet or signaling NaN.

edited Jul 16 '16 at 13:02

answered Jul 16 '16 at 03:25

robot1208

191
1
7

You omitted a couple of trailing zeros. Negative zero is 0x80000000 – Nayuki Jul 16 '16 at 03:26
We were provided with a testing code, and that is the number that it fails on. (Possibly in addition to others) – diaga Jul 16 '16 at 03:29
1

I'm unclear as to which number you are referring to fails: 0x80000000 = -0.0 , 0x00800000 = 1.17549435E-38 , 0x4b000000 = 8388608 . – robot1208 Jul 16 '16 at 03:42
The decimal int given in the question should be pretty unambiguous. – Mark Ransom Jul 16 '16 at 03:46
FWIW, this should not be an answer, it should be a comment. – Rudy Velthuis Jul 16 '16 at 09:45

Bitwise multiplication of a floating point number

1 Answers1