bitwise left shift in Java produces the same values...?

Question

I'm writing a left shift algorithm in Java and have been doing some left shift calculations by hand. All of these numbers are typed as byte, btw.

Let's say I'm working with 8-bit integers from -128 to 127.

Then from my calculations:

(-113 << 4) == (-65 << 4) == -16

because

-113 == 1 0 0 0 1 1 1 1 
-113 << 4 == 1 1 1 1 0 0 0 0 == -16

but so does

-65 == 1 0 1 1 1 1 1 1
-65 << 4  == 1 1 1 1 0 0 0 0 == -16

So left shifting -113 by 4 and left shifting -65 by 4 result in the same value? Shouldn't all left shift operations produce unique values? Or do I have this right?

EDIT:

I'm working in Java and all of my numbers are bytes and the JVM is throwing an "error: loss of precision error" and this is what is also precipitating my question. Thanks!

The question isn't clear. What are you trying to figure out? — Amit, Jan 30 '16 at 22:22
This is how it work. "every bit in the operand is simply moved a given number of bit positions, and the vacant bit-positions are filled in, usually with zeros (contrast with a circular shift)." https://en.wikipedia.org/wiki/Logical_shift — Piotr Siekierski, Jan 30 '16 at 22:25
Since these are negative values you'll probably want to preserve the sign bit, but as Amit says it's not entirely clear what you're trying to do. — 500 - Internal Server Error, Jan 30 '16 at 22:26
@M.M Well, I'm working with Java. My code is as follows: byte << byte and it's not compiling, throwing loss of precision...So I guess you can't shift with Bytes in Java? — Dimpermanence, Jan 30 '16 at 23:00
@M.M Good call on the language tag. I've edited for clarity. — Dimpermanence, Jan 30 '16 at 23:04
"Shouldn't all left shift operations produce unique values? " No. — Louis Wasserman, Jan 31 '16 at 04:55

score 1 · Accepted Answer · edited May 23 '17 at 12:15

This and many more shifting-related questions have been discussed in-depth in an SO question here. It also explains why your bits are counted differently when using signed expressions.

Concerning your question:

The same value from different source values issue you encountered comes from the fact that you're throwing information away by left-shifting bits out of the word. One of the formerly number-related information carrying bits has in both cases become the sign bit.

If you would have shifted -16 by only three bits, you would have even ended up with a positive number:

0 1 1 1 1 0 0 0 = 120

And, if you shifted out all of the bits (<< 8), you will also end up at the same value:

0 0 0 0 0 0 0 0 = 0

So you can indeed come up with the same number by shifting the bits of different values.

I hope that answers your question.

Glad that helped. If you want the behavior you described (i.e., not lose information and always get a different number), you might want to look at **rotation** instead of shifting. — , Jan 31 '16 at 07:57

bitwise left shift in Java produces the same values...?

1 Answers1