Unary "~" operator - What exactly is happening here?

Question

I recently did a Java course (1 week crash course), and we covered some binary mathematics.

This unary ~ operator (tilde I think it's called?) was explained to us thus:

It inverts the bit pattern turning every "0" into a "1" and every "1" into a "0". e.g. There are 8 bits to a byte. If you have the following byte: 00000000 the inverted value would change to become 11111111.

The above explanation is clear and concise, and totally makes sense to me. Until, that is, I try to implement it.

Given this:

byte x = 3;
byte y = 5;
System.out.println(~x);
System.out.println(~y);

The output is:

-4  
-6

I'm very confused about how this happens.

If +3 in binary is 11, then the inversion of this would be 00, which clearly isn't -3.

But as there are 8 bits in a byte, then shouldn't the binary representation of +3 be written as 00000011?

Which would invert to become 11111100. Converted back to decimal value this would be 252. If however you write the +3 as 011, then it does indeed convert to 100, which is +4, but then how do you know it's a negative number?

How about if you try 0011, which converts to 1100, which if you use the first bit as a sign, then it does indeed become -4.

Ah - so at this point I thought I was getting somewhere.

But then I got to the second value of y = 5.

How do we write this? Using the same logic, +5 converts to binary 0101, which inverts to 1010.

And it's around now that I'm horribly confused. This looks to represent either a signed value of -2, or an unsigned value of +10 decimal? Neither of which are the -6 I'm getting printed out.

Again, if I increase the length up to the 8 digits of a byte, +5 is 00000101, which inverted becomes 11111010. And I really can't find a way to turn this into -6.

Does anyone out there understand this, as I have no idea what is happening here and the more numbers I print out the more confused I become.

Google doesn't seem to come up with anything much on this - maybe it doesn't like looking at little operator signs.. :-(

Answer 1

See this demonstration: -

3 ->  0011
~3 -> 1100  -> -4 (2's complement)

5 -> 0101
~5 -> 1010 -> -6 (2's complement)

Since signed integers are stored as 2's complement, taking 2's complement of 1100 gives you 4. Now since 1100 is a negative number. So, the result is -4. Same is the case with 1010.

1100 
0011  - 1's complement
0100  - 2's complement  - value = 4 (take negative)

Answer 2

From wikipedia: In two's complement notation, a non-negative number is represented by its ordinary binary representation; in this case, the most significant bit is 0. The two's complement operation is the negation operation, so negative numbers are represented by the two's complement of the absolute value.
To get the two's complement of a binary number, the bits are inverted, or "flipped", by using the bitwise NOT operation; the value of 1 is then added to the resulting value, ignoring the overflow which occurs when taking the two's complement of 0. http://en.wikipedia.org/wiki/Two%27s_complement

So if you have 0101 which is +5 the inverse of that is 1010, which is -5.

You don't really read the 010 as a 5 though, but when you see the 1 at the beginning, you know that to get the number you have to invert the rest of the digits again to get the positive number which you want to negate. If that makes sense.

It's a bit of an alien concept if you have not worked with it before. It's certainly not the way that decimal numbers work, but it is actually simple once you see what happening.

A value of 8 decimal is written as 01010, which negates to 10101. The first digit (1) means it's negative, and then you flip the rest back to get the numeric value: 1010.

One thing to remember is that Two's complement is not the same as ordinary old binary system counting. In normal binary the value of 10101 (which in Two's complement is -8 as above) is of course 21. I guess this is where the confusion comes - how do you tell the difference by looking at them? You must know which representation has been used in order to decide what the value of the number actually is. There is also One's complement which differs slightly.

A good tutorial on binary maths, including One's and Two's complement is given here. http://www.math.grin.edu/~rebelsky/Courses/152/97F/Readings/student-binary

Answer 3

Signed integers are almost universally stored using twos complement. This means inverting the bits (taking the one's complement) and adding one. This way you don't have two representations of integer zero (+0 and -0), and certain signed operations become easier to implement in hardware.