Bit- manipulation

Question

I'm implementing a JPEG-Decoder and in one step I need to determine the sign of a value from a given number of bits (positive if 1th bit = 1). When the 1th bit is 0 then I have to get the two's complement from this value and additionaly add 1 to result.

I've have the following function to do this job:

#include <stdio.h>      /* printf */
#include <string.h>     /* strcat */
#include <stdlib.h>     /* strtol */

typedef int bool;
#define true 1
#define false 0

int DetermineSign(int val, int nBits)
{
    bool negative = val < (1<<(nBits-1));

    if (negative)
    {
        // (-1 << (s)), makes the last bit a 1, so we have 1000,0000 for example for 8 bits

        val = val + (-1 << (nBits)) + 1;
    }

    // Else its unsigned, just return
    return val;
}

Could anyone explain please what does this expression (-1 << (nBits)) do and how it works? I know there is a comment from author to explain it, but I also tested it with the following function and it returns another result.

const char *byte_to_binary(int x)
{
    static char b[9];
    b[0] = '\0';

    int z;
    for (z = 128; z > 0; z >>= 1)
    {
        strcat(b, ((x & z) == z) ? "1" : "0");
    }

    return b;
}

int main(void)
{
    char testValue = 0;

    testValue = (-1 <<(testValue));

    printf("%s\n", byte_to_binary(testValue)); // output 1111 1111 doesn't it has to be 1000 000?

    return 0;
}

Thank you!

You may want to read this: http://stackoverflow.com/questions/809227/is-it-safe-to-use-1-to-set-all-bits-to-true — martinkunev, Sep 02 '16 at 09:37
it adds zeros in the less significative bits to a mask made all of ones (in two's complement, -1 is the pattern `1111111...111`. So `-1 << 3` is `11111...111000`. — Luis Colorado, Sep 05 '16 at 06:18

barak manos · Accepted Answer · 2016-09-02T09:38:50.590

4

It replaces the right-most (least significant) ones with zeros:

-1 << 0 == 0xFFFFFFFF
-1 << 1 == 0xFFFFFFFE
-1 << 2 == 0xFFFFFFFC
-1 << 3 == 0xFFFFFFF8
-1 << 4 == 0xFFFFFFF0
...

edited Sep 02 '16 at 09:38

answered Sep 02 '16 at 09:33

barak manos

29,648
10
62
114

The amount of `F`s depends on the value of `sizeof int` on your platform of course... – barak manos Sep 02 '16 at 09:43
Exactly! My problem was, that I didn't interpret `-1` as `0xFFFFFFFF`. Thanks! – Usam Sep 02 '16 at 09:44
@Samashki95: You're welcome. Please keep in mind my comment above (although in most cases `-1` is indeed "made of" 8 `F`s). – barak manos Sep 02 '16 at 09:46
@Samashki95: BTW, I tend to use `~0` instead of `-1`. – barak manos Sep 02 '16 at 09:48
What's the reason of using -0? – LPs Sep 02 '16 at 10:13
@LPs: No special reason, I just like it better for bit-manipulation code. BTW, it's `~0`, not `-0`. – barak manos Sep 02 '16 at 10:30

coder · Answer 2 · 2016-09-02T09:45:17.850

1

What (-1 << (nBits)) does is that the left operands value(-1) is moved left by the number of bits specified by the right operand (nBits). In decimal representation the expression x<<y equals to multiplying x by 2 y times,for example:

x=2,y=3 ,after x<<y x equals to 16.

edited Sep 02 '16 at 09:45

answered Sep 02 '16 at 09:33

coder

12,832
5
39
53

Bit- manipulation

2 Answers2