Return the bit-level equivalent of expression -f for floating point argument f

Question

As part of the first big coding project for my coding class, an intro to C, the following question was asked, do note the restrictions:

 /* 
 * Neg_Float - Return bit-level equivalent of expression -f for
 *   floating point argument f.
 *   Both the argument and result are passed as unsigned int's, but
 *   they are to be interpreted as the bit-level representations of
 *   single-precision floating point values.
 *   When argument is NaN, return argument.
 *   Legal operations: Any integer/unsigned operations incl. ||, &&. also if, while
 *   Max ops: 8
 *   Rating: 2
 */

Here is my code so far:

unsigned Neg_Float(unsigned uf) {
    unsigned exp = (uf >> 23) & 0xff;
    if (exp == 0xff)
        return uf; //NaN
    else {
        return (uf ^ 0x80000000);
    }
}

When I ran this piece of code through the checking software, I got this error:

ERROR: Test Neg_Float(0[0x0]) failed...
...Gives 0[0x0]. Should be -2147483648[0x80000000]

The purpose of this assignment is to learn floating point and bit manipulation. So I would appreciate if you would explain where I went wrong, and how I can fix it.

Also, yes I'm aware, that there is pretty much the same question in another post that's like 10 years old, but it doesn't answer the question at all.

[This](https://stackoverflow.com/a/44611722/1911064) related post should be helpful for you. — Axel Kemper, Jan 26 '23 at 09:37
The posted code doesn't return `0` when called as `Neg_Float(0)` — Support Ukraine, Jan 26 '23 at 09:39
Besides that it's rather strange that the expected value is printed as a negative number.... The function returns an unsigned integer — Support Ukraine, Jan 26 '23 at 09:40
I vote to close as the problem can't be reproduced. See https://ideone.com/KbDhAB — Support Ukraine, Jan 26 '23 at 09:44
That's not the test I'd expect to fail. The code *will* fail for ±infinity. — user3386109, Jan 26 '23 at 09:48
@user3386109 Good point. The code treats infinity and NaN the same way. — Support Ukraine, Jan 26 '23 at 09:51
The code is incorrect but the test bed fails too... Why close this question when an answer can provide useful insights? — chqrlie, Jan 26 '23 at 10:01
Here is a corrected version: `unsigned Neg_Float(unsigned uf) { return (uf & 0x7fffffff) > 0x7f800000 ? uf : uf ^ 0x80000000; }` or within the restrictions: `unsigned Neg_Float(unsigned uf) { if ((uf & 0x7fffffff) > 0x7f800000) return uf; else return uf ^ 0x80000000; }` — chqrlie, Jan 26 '23 at 10:03

score 1 · Accepted Answer · answered Jan 28 '23 at 19:19

The code is incorrect, but not for the reason the testing program mentions: it behaves correctly for zeroes (0.0 and -0.0), but it fails for infinities because the NaN test is incorrect.

Here is a modified version:

unsigned Neg_Float(unsigned uf) {
    return (uf & 0x7fffffff) > 0x7f800000 ? uf : uf ^ 0x80000000;
}

If you cannot use the ternary operator, here is an alternative version:

unsigned Neg_Float(unsigned uf) {
    if ((uf & 0x7fffffff) > 0x7f800000)
        return uf;
    else
        return uf ^ 0x80000000;
}

Return the bit-level equivalent of expression -f for floating point argument f

1 Answers1