shifting

[Anonymous]

This is in regards to the appliedreasoning mock exam
Question 23: what's the value of (byte)0X81 >> 2
a) 0x20
b) 0x3fffffe0
c) 0xe0
d) 0xffffffe0
THe answer given is d, but I thought c. The number 0x81 would be converted to an int, then shifted, and is cast back down to a byte- or so I thought. What's going on here?
Another one related to that is question 25: give the result of 0x1 << 36
The answer says it uses 36 mod 31 to get 0x1 << 5, I thought it was modulo 32? Anyway I'm not sure how to test this, when I try and run something like this, I get an error saying "left shift exceeds size of the type being shifted"
Please help!
Thanks!

[Manju Swamy]

Here are the quotes from JLS:

---

An integer literal may be expressed in decimal (base 10), hexadecimal (base 16), or octal (base 8):
An integer literal is of type long if it is suffixed with an ASCII letter L or l (ell); otherwise it is of type int (�4.2.1).

---

int i = 0x81;
The value of Ox81 in decimal system is 129.
The binary representation is 0000 0000 0000 0000 0000 0000 1000 0001
byte b = (byte) i;
When the value is casted to byte the last 8 bits are stored in the variable b.
The binary representation is 1000 0001 (the most significant bit is the sign bit).
Now value of b in decimal system is -127.
System.out.println("value of b >> 2 in Decimal: " + b >> 2);

Following are the quote from Mughal and Rasmussen book:
Since char, byte and short operands are promoted to either int or long, the result of applying these bitwise operators is always either an int or a long value.

Additional reading on Shift Operators from JLS.
Now the byte b variable is promoted to int.
The binary representation is 1111 1111 1111 1111 1111 1111 1000 0001
The decimal value is still -127.
The Hex representation is ffffff81
After the shit operation >> (shift right with sigh bit) the return value is int in this case.
The binary representation is 1111 1111 1111 1111 1111 1111 1110 0000
The decimal value is -32.
The Hex representation is ffffffe0
Hence the answer.

Another one related to that is question 25: give the result of 0x1 << 36<br /> The answer says it uses 36 mod 31 to get 0x1 << 5, I thought it was modulo 32? Anyway I am not sure how to test this, when I try and run something like this, I get an error saying "left shift exceeds size of the type being shifted"<br /> <br />

<br /> You are right on this one. You can verify by running the following code and reading the above mention JLS on Shift Operators.<br /> Note: Moderators this can be moved Mock Exam Errata.<br />

class Shift {
    public static void main(String args[]) {
        System.out.println("Result of (byte)0x81>>2 is: " + Integer.toHexString((byte)0x81 >> 2));
        // Step by step analysis
        int i = 0x81;
        System.out.println("value of i in Decimal: " + i);
        System.out.println("value of i in Binary: " + Integer.toBinaryString(i));
        System.out.println("value of i in Hex: " + Integer.toHexString(i) + "\n");
        // Now casting to byte
        byte b = (byte)i;
        System.out.println("value of b in Decimal: " + b);
        // Apparently Byte wrapper class does not have toBinaryString and
        // toHexString.  I have to use Integer wrapper class which promotes
        // byte b to int value
        System.out.println("value of b in Binary: " + Integer.toBinaryString(b));
        System.out.println("value of b in Hex: " + Integer.toHexString(b) + "\n");
        System.out.println("value of b >> 2 in Decimal: " + (b >> 2) );
        System.out.println("value of b >> 2 in Binary: " + Integer.toBinaryString(b >> 2) );
        System.out.println("value of b >> 2 in Hex:" +  Integer.toHexString(b >> 2) + "\n");
        System.out.println("Result of 0x1 << 36 is: " + Integer.toHexString(0x1 << 36));
        System.out.println("36 % (Mod operator) 32 is: " + (36 % 32));
        System.out.println("Result of 0x1 << 4 is: " + Integer.toHexString(0x1 << 4));
    }
}

[This message has been edited by Manju Swamy (edited April 26, 2000).]

[Anonymous]

Thank you, that helps clear some things up. The (byte) cast was bringing 0x81 down to byte, but the shift promoted it back to integer, thus giving the answer as a hexadecimal int.
I still got the "left shift exceeds size of the type being shifted" error on the following line:
System.out.println("Result of 0x1 << 36 is: " + Integer.toHexString(0x1 << 36));

However, I do understand how to get the answer on that one. Thank you.

[Manju Swamy]

Here is the code out put:

Result of (byte)0x81>>2 is: ffffffe0
value of i in Decimal: 129
value of i in Binary: 10000001
value of i in Hex: 81
value of b in Decimal: -127
value of b in Binary: 11111111111111111111111110000001
value of b in Hex: ffffff81
value of b >> 2 in Decimal: -32
value of b >> 2 in Binary: 11111111111111111111111111100000
value of b >> 2 in Hex:ffffffe0
Result of 0x1 << 36 is: 10
36 % (Mod operator) 32 is: 4
Result of 0x1 << 4 is: 10

I am using winnt java from SUN version 1.2.2.
Here is how you can find the java version.
C:\>java -version
java version "1.2.2"
Classic VM (build JDK-1.2.2-001, native threads, symcjit)
What platform / java version are you using?

[Anonymous]

My java version says:
Java version "1.2.2"
Classic VM (build JDK-1.2.2-W, native threads, symcjit)
I'm running on Windows NT 4.0

[Suma Narayan]

Hi,
The above example worked for me. My java version is
java version "1.2.1"
Classic VM (build JDK-1.2.1-A, native threads)
and I have Windows 95.

[maha anna]

Brain,
0x1 << 36 is equivalent to
0x1 << 0x ff ff ff 00100100 ( I am using spaces and 0's and 1's just to make it visually clear )
Since the decimal literal 36 defaults to primitive type 'int'
LHS operand shiftoperator RHS operand
According to JLS when you use shift operatiors (<<, >>, >>>), if the LHS operand is int then only the last 5 bits of RHS operand is used for shifting . SImillarly if the LHS operand is long then only the last 6 bits of RHS operand is used for shifting . Also note that shift operation can take place ONLY on int/long LHS operands. If anything < int type (byte/short/char) they are first promoted to int and then shifting takes place. LHS operand can't be float/double.
So in this case the val 1 is shifted left 4 places. (Since the last 5 bits (00100) constitutes value of 4. Also note that every time you left(right) shift by 1 place you in effect multiply (divide> the val by 2
So in my mind I just calculate the value 1 becomes
1 then 2 then 4 then 8 then 16 (after 4 shifts)
This is the correct result according to the JLS. In JDK 1.2.2 under WIN98 we get this result.
regds
maha anna
[This message has been edited by maha anna (edited April 27, 2000).]

[Anonymous]

Thank you for the explanation. It is clear now what is going on
Brian

[Anonymous]

Just some investigative work...for clarification...
The decimal value of 0x1 << 4 is 16, as explained.
In Manju's program, the use the of Integer.toHexString()
method prints 10. Which is to be read as 0x10. Maybe we
should change the last println statement to:
System.out.println("Result of 0x1 << 4 is: " + "0x" + Integer.toHexString(0x1 << 4));
For a couple of minutes, I was .
I am posting this just to clarify, in case
I have company in the confusion.
Regds.
- satya

[maha anna]

Thanks for sharing your experience Satya. I really appreciate your helpful nature. Yes appending "0x" helps in perceiving the result as HexValue.
regds
maha anna

[Anonymous]

Hi,
could someone please explain this
if the LHS operand is int then only the last 5 bits of RHS operand is used for shifting . SImillarly if the LHS operand is long then only the last 6 bits of RHS operand is used for shifting especially the significance of 5 for int and 6 for long.
thanx
Rahul Mkar
[This message has been edited by rahul_mkar (edited June 05, 2000).]

[Anonymous]

rahul:
Say you are shifting my_int value by 34 (some num > 32)
then the actual shift is equal to shifting my_int with
2.
34 = 0010 0010
Now since we are shifting an int, only the low order 5
bits are used from the above num which will be 0 0010
ie; 2 (which is also 34-32 ).
However if you are shifting a my_long value by 34
the the lower order 6 bits are used. Meaning the variable
my_long is actually shifted by 34 bits 10 0010 and not
by 2 bits as with ints.
I thought every thing was clear above. Anyways, hope I am
able to show the difference. Also try and play with this code.
To make you think abt this I used 33 in the code....

public class Test2  {

public static void main(String[] arg){

System.out.print("128 >> 33 = " + (128>>33) 
 + "\t" );
System.out.println("128 shifted by 33 (0010 0001).");
System.out.print("128 >> 1 = " + (128>>1) 
 + "\t");

System.out.println("128 shifted by 1 (0000 0001).");

System.out.println("\nShifting 128L now ...... ");

System.out.print("128L >> 33 = " + (128L >> 33) 
 + "\t" );
System.out.println("128L shifted by 33 (0010 0001).");
System.out.print("128L >> 1 = " + (128L>>1) 
 + "\t");
System.out.println("128L shifted by 1 (0000 0001).");

}


}

Output is:
128 >> 33 = 64 128 shifted by 33 (0010 0001).
128 >> 1 = 64 128 shifted by 1 (0000 0001).
Shifting 128L now ......
128L >> 33 = 0 128L shifted by 33 (0010 0001).
128L >> 1 = 64 128L shifted by 1 (0000 0001).
Hope this helps, else take a break and read from the
beginning of the whole thread.
Regds.
- satya