Is there an Error with Unsigned Shift in Java ???

look at this:

if you make an >>> Operation to a Byte:

   for (byte sourc = Byte.MIN_VALUE; sourc < Byte.MAX_VALUE; sourc++) {
	cat.info(sourc + " >>> 1 = "+ (byte)(sourc >> 1));
			}
this seems to not really work:

look:

   -126>>>1 = -63

if you make this manually, you get this:

   -126 = (bin) 1000 0010
                |      | 
                |      +-------> the value 1000 0000 = -128
                +--------------> this is the minus

if you shift it RIGHT UNSIGNED, it should be:

   1000 0010 >>> 1 = 0100 0001 = +65

this is clear: look:
   (original Java)          should be!!

     121 >>> 1 = 60         60 (OK)
     122 >>> 1 = 61         61 (OK)
     123 >>> 1 = 61         61 (OK)
     124 >>> 1 = 62         62 (OK)
     125 >>> 1 = 62         62 (OK)
     126 >>> 1 = 63         63 (OK)
     127 >>> 1 = 63         63 (OK)
    -128 >>> 1 =-64         64 
    -127 >>> 1 =-64         64 
    -126 >>> 1 =-63         65 
    -125 >>> 1 =-63         65
    -124 >>> 1 =-62         66
    -123 >>> 1 =-62         66
    -122 >>> 1 =-61         67
    -121 >>> 1 =-61         67
     
now, java does the following, due to the Java Language Spec:

the >>> Operator makes a cast to int.
then the result is processed, and we do a cast back to byte.

with this in Mind, we can see the truth:

   (original Java)          should be!!

     121 >>> 1 = 60         60 (OK)
     122 >>> 1 = 61         61 (OK)
     123 >>> 1 = 61         61 (OK)
     124 >>> 1 = 62         62 (OK)
     125 >>> 1 = 62         62 (OK)
     126 >>> 1 = 63         63 (OK)
     127 >>> 1 = 63         63 (OK)
    -128 >>> 1 = 2147483584 64
    -127 >>> 1 = 2147483584 64 
    -126 >>> 1 = 2147483585 65 
    -125 >>> 1 = 2147483585 65
    -124 >>> 1 = 2147483586 66
    -123 >>> 1 = 2147483586 66
    -122 >>> 1 = 2147483587 67
    -121 >>> 1 = 2147483587 67

now we see: the unsigned shift Operator DOES really shift a negative Value,
without care about the Signs bit, so all Negative does get positive!!!

the problem is the cast to byte!!!

----

this is a possible Solution:

    for (source = Byte.MIN_VALUE; source < Byte.MAX_VALUE; source++) {
		cat.info(source	+ " >>> 1 = "+ ( (byte)(source >> 1) & Byte._0111_1111 )      );
		}

----

VisualC++ has similar shifting problems, requiring explicit casts to signedness and size to do it correctly. Perhaps the same is true of Java? 

----
But this is '''not a problem''' since, according to Java specification, the byte is augmented to an int before shifting.

----

Yes, that's true, if you say: the Java language works correctly, because of the Specification.

You are Right!! This is not a Bug!

But, that's Useless if you need a '''really''' Unsigned Shift for a Byte!!

----

I thought everybody knew that '''A "FEATURE" IS A DOCUMENTED BUG'''.

----

''Not a bug, but still a problem. The bit-fiddling code I write in Java is a mixture of occasional obscure type-promotion errors and an otherwise ridiculously defensive explicit-casting programming style. Much more so than in C, where you have unsigned types. I've recently found some very simple CommonLisp primitives for manipulating sub-bytes of integers ''extremely'' handy - it would be great to see them added to other languages. Details at http://www.lispworks.com/reference/HyperSpec/Body/12_aacb.htm -- LukeGorrie''

-----

Here's a Way to do it:

	/**
	 * Method unsigned.
	 * 
	 * does the following Mapping:
	 * 
	 * (byte)0  = +0   = b0000_0000 ---> 0 (int)
	 * (byte)1  = +1   = b0000_0001 ---> 1 (int)
	 * .
	 * .
	 * (byte)127= +127 = b0111_1111 ---> 127(int)
	 * (byte)128= -128 = b1000_0000 ---> 128(int)
	 * (byte)129= -127 = b1000_0001 ---> 129(int)
	 * .
	 * .
	 * (byte)253= -  3 = b1111_1101 ---> 253(int)
	 * (byte)254= -  2 = b1111_1110 ---> 254(int)
	 * (byte)255= -  1 = b1111_1111 ---> 255(int)
	 * 
	 * The way how to do this is here:
	 * 
	 * http://forum.java.sun.com/thread.jsp?forum=4&thread=296372
	 * Topic: Unsigned Byte Possible? 
	 * 
	 * 
	 * 
	 * How does this work ???
	 * 
	 * 
	 * look:
	 * 
	 * +127(int) = b1111111
	 * -128(int) = b11111111111111111111111110000000 & 0xFF = b10000000
	 * -127(int) = b11111111111111111111111110000001 & 0xFF = b10000001
	 * 
	 * so, this is WORKING !!!!!!!
	 * 
	 * @param b
	 * @return int
	 */
	int unsigned(byte b) {
		return ((int)b)&0xFF; //so, only the lowest Byte of the int is taken.
		
	}

-----

Now you can:

	byte b = (byte)128;
        x = unsigned(b) >>> 1 


----

See
ArithmeticShiftingConsideredHarmful