View source

{{LSL Header}}{{RightToc}}

== Unsigned vs. Arithmetic ==

There are two types of Right Shifts, that can be performed on an integer. They are: Unsigned and Arithmetic. LSL currently only supports Arithmetic. The difference between the two modes is how it fills the bits revealed. With the unsigned mode, the revealed bits are always zero; in Arithmetic mode, it duplicates the old top bit to all the new bits. If you take the expression <code>value >> count</code> where ''value'' is arithmetically shifted right ''count'' bits, then this is the same mathematically as doing <code>value / (2<sup>count</sup>)</code> or in LSL <code>value / [[llPow]](2.0, count)</code>.

== How to do Unsigned Right Shifts in LSL ==

Since LSL does not have a unsigned right shift operator you have to do it yourself. There are two methods for doing this, each with it's advantages and disadvantages.

There is a feature suggestion to add an unsigned right shift operator to LSL: {{JIRA|SVC-1171}}

=== Method 1 ===
<lsl>(value >> count) & ~((~value) >> count);</lsl>
This method is good when count is dynamic.
It works because all the bits that need to be turned on will be turned on both sides of the AND but on only one side will the arithmetic right shift cause the sign bit to be extended. The result of the and is a value that is always a unsigned right shift.

=== Method 2 ===
<lsl>(value >> count) & mask;</lsl>
This method can only be used when count is a constant value. You use a constant mask to remove the extended sign bits. Example: <code>(value >> 5) & 0x07FFFFFF</code> As you can see the top five bits have been turned off in the mask value, if you have trouble seeing that, you can just use the lookup table below.

{|
|+'''Mask Lookup Table'''
|
{|{{Prettytable}}
|-{{Hl2}}
! Shift
! Mask
! Mask - Bit View
|- align="right"
| 0
| {{LSL Hex|0xFFFFFFFF|}}
| 11111111 11111111<br/>11111111 11111111
|- align="right"
| 1
| {{LSL Hex|0x7FFFFFFF|}}
| 01111111 11111111<br/>11111111 11111111
|- align="right"
| 2
| {{LSL Hex|0x3FFFFFFF|}}
| 00111111 11111111<br/>11111111 11111111
|- align="right"
| 3
| {{LSL Hex|0x1FFFFFFF|}}
| 00011111 11111111<br/>11111111 11111111
|- align="right"
| 4
| {{LSL Hex|0x0FFFFFFF|}}
| 00001111 11111111<br/>11111111 11111111
|- align="right"
| 5
| {{LSL Hex|0x07FFFFFF|}}
| 00000111 11111111<br/>11111111 11111111
|- align="right"
| 6
| {{LSL Hex|0x03FFFFFF|}}
| 00000011 11111111<br/>11111111 11111111
|- align="right"
| 7
| {{LSL Hex|0x01FFFFFF|}}
| 00000001 11111111<br/>11111111 11111111
|}
|
{|{{Prettytable}}
|-{{Hl2}}
! Shift
! Mask
! Mask - Bit View
|- align="right"
| 8
| {{LSL Hex|0x00FFFFFF|}}
| 00000000 11111111<br/>11111111 11111111
|- align="right"
| 9
| {{LSL Hex|0x007FFFFF|}}
| 00000000 01111111<br/>11111111 11111111
|- align="right"
| 10
| {{LSL Hex|0x003FFFFF|}}
| 00000000 00111111<br/>11111111 11111111
|- align="right"
| 11
| {{LSL Hex|0x001FFFFF|}}
| 00000000 00011111<br/>11111111 11111111
|- align="right"
| 12
| {{LSL Hex|0x000FFFFF|}}
| 00000000 00001111<br/>11111111 11111111
|- align="right"
| 13
| {{LSL Hex|0x0007FFFF|}}
| 00000000 00000111<br/>11111111 11111111
|- align="right"
| 14
| {{LSL Hex|0x0003FFFF|}}
| 00000000 00000011<br/>11111111 11111111
|- align="right"
| 15
| {{LSL Hex|0x0001FFFF|}}
| 00000000 00000001<br/>11111111 11111111
|}
|
{|{{Prettytable}}
|-{{Hl2}}
! Shift
! Mask
! Mask - Bit View
|- align="right"
| 16
| {{LSL Hex|0x0000FFFF|}}
| 11111111 11111111
|- align="right"
| 17
| {{LSL Hex|0x00007FFF|}}
| 01111111 11111111
|- align="right"
| 18
| {{LSL Hex|0x00003FFF|}}
| 00111111 11111111
|- align="right"
| 19
| {{LSL Hex|0x00001FFF|}}
| 00011111 11111111
|- align="right"
| 20
| {{LSL Hex|0x00000FFF|}}
| 00001111 11111111
|- align="right"
| 21
| {{LSL Hex|0x000007FF|}}
| 00000111 11111111
|- align="right"
| 22
| {{LSL Hex|0x000003FF|}}
| 00000011 11111111
|- align="right"
| 23
| {{LSL Hex|0x000001FF|}}
| 00000001 11111111
|- align="right"
| 24
| {{LSL Hex|0x000000FF|}}
| 00000000 11111111
|- align="right"
| 25
| {{LSL Hex|0x0000007F|}}
| 00000000 01111111
|- align="right"
| 26
| {{LSL Hex|0x0000003F|}}
| 00000000 00111111
|- align="right"
| 27
| {{LSL Hex|0x0000001F|}}
| 00000000 00011111
|- align="right"
| 28
| {{LSL Hex|0x0000000F|}}
| 00000000 00001111
|- align="right"
| 29
| {{LSL Hex|0x00000007|}}
| 00000000 00000111
|- align="right"
| 30
| {{LSL Hex|0x00000003|}}
| 00000000 00000011
|- align="right"
| 31
| {{LSL Hex|0x00000001|}}
| 00000000 00000001
|- align="right"
| 32
| {{LSL Hex|0x00000000|}}
| 00000000 00000000
|}
|}

== Example Unsigned Right Shift Function ==

Here's a function that encapsulates the first method. It allows for a signed 32 bit integer along with a value indicating how far to shift the bits to be executed as an unsigned right shift.

<lsl>// the lsl right shift is an arithmetic right shift,
// this means it more closely resembles dividing by a
// positive power of two then a unsigned right shift.
// To perform a unsigned right shift you need to be clever
integer rightShift(integer value, integer count)
{
    return (value >> count) & ~((~value) >> count);
    //This works because only once side of the '&' operation
    //Has the sign bit extended by the arithmetic right shift
    //The purpose of flipping of the bits on the right side 
    //ensures this, the subsequent '&' removes the extended
    //sign bits.
}</lsl>
'''Example Usage:'''
<lsl>default
{
    state_entry()
    {

        // output should be 268435449
        llSay(DEBUG_CHANNEL, (string)rightShift(-99, 4));

        // before: 1111 1111 1111 1111 1111 1111 1001 1101
        // after:  0000 1111 1111 1111 1111 1111 1111 1001
    }
}</lsl>

{{LSLC|Examples|Right Shift}}
[[Category: LSL Encryption]]