Help Understanding some Bitwise Operators?

Hi.

Could some one tell me what ~, >>, ^ and << do?

I know there NOT, RIGHT SWITCH, XOR and LEFT SWITCH, but I don't know what that means.

I've searched and searched but all I'm finding is examples in binary, could someone just give me a simple practical exaple of them in use?

Thanks!

~ NOT

flying = True;
If IHitTheGround Then flying = ~flying //.flying is now False
IF (~flying) Then IAmOnTheGround

<< SHIFT BITS LEFT (multiplication by powers of 2)

1 << 1 = 2 binary 0001 << 1 = 0010
3 << 2 = 12 binary 0011 << 2 = 1100

>> SHIFT BITS RIGHT (division by powers of 2)

0100 >> 1 = 0010 (4 >> 1 = 2)
0110 >> 1 = 0011 (6 >> 1 = 3)

When bit shifting just be careful to recognise that bits get shifted off the ends.

0001 >> 3 = 0000
0010 >> 3 = 0000
0100 >> 3 = 0000

0011 << 3 = 1000
1001 << 3 = 1000

A practical example of bit shifting for a purpose other than mutiply/divide is when you want to read a stream of bits, one bit at a time say from a disk file when you can only read from file one byte at time:

byte buffer;
integer bitcounter = 0;

Function GetBit()
{
If bitcounter = 0 Then
buffer = GetByteFromFile;
bitcounter = 8;
End If
bitcounter = bitcounter -1;
return buffer >> bitcounter AND 1; /// and 1 masks off the buffer returning only the value of the right-most bit after the shift
}

^ XOR

This is useful for obfuscation (amongst other things) as XOR is reversible.

if you have a string of numbers say 3,1,0,2 and you seed a pseudo-random number generator with say 3 so that it produces a string of numbers 2,3,2,1 (or whatever) then:

3 XOR 2 = 1
1 XOR 3 = 2
0 XOR 2 = 2
2 XOR 1 = 3

Giving you a new string: 1,2,2,3

If you reseed the pseudo-random number generator with the original seed (3) and process the new string with XOR it restores the string to its original values:

1 XOR 2 = 3
2 XOR 3 = 1
2 XOR 2 = 0
3 XOR 1 = 2

in binary
~10101 == 01010 (swap all the digits for their opposite)
10101 >> 1 == 11010 (add the same number to the front, remove the last)
10101 << 1 = 01010 (remove the first, add zero to the end)
in decimal
~X == -(X + 1) == -X - 1 (at least with signed integers)
X >> Y == X / (llPow( 2, Y ); (fractions truncated)
X << Y == X * (llPow( 2, Y ); (results past min/max int give other results)
except for ~ they are really only useful to imagine in binary or as truth tables

^ == True if both bits are different
| == True if either bit is true
& == True if both bits are true
order doesn't matter, result is false if it fails the above conditions. to reverse the outcome, use ~ on the result. compare them in columns.

Bear, watch your use of the tilde (~) versus the shriek (!).

In LSL, zero is logically interpreted to be false, and any non-zero value is logically interpreted to be true. The predefined constants TRUE and FALSE, however, are slightly different:

TRUE is equal to 1, not any non-zero integer. So:
!TRUE, the logical-not, is equal to FALSE, which is zero.
~TRUE, the bitwise-not, is the one's complement, which is a reversal of all its bits, and is equal to -2.
So, !TRUE is logically false, but ~TRUE is still logically interpreted to be true.

This is why I advise scripters to use TRUE and FALSE with direct assignment or to modify them with the logical operators, but to avoid these constants entirely in expressions and mechanisms using arithmetic or bitwise operations.

Yes True. Each language has its own peculiarities.

Learn binary!!!

Really.. This stuff will make more sense if you do. That's why the examples are in binary!

it may help to think of binary as a string of 32 true/false variables, with the fun property that each true is multiplied by a power of 2 (the first being power 0) and then added to get a number.

A slightly belated happy 6k to you!

woo hoo, only 133 more posts to binary 6k, ty =)

Know any resource on the web I can learn the Binary needed?

Picture an odometer - the thing that tracks how many miles (or km) your car has gone.

It starts at all 0's.

Move forward - add to the milage - and the rightmost digit progresses through all the numbers.

When the rightmost digit goes past 9, it rolls on back to 0 and the digit to the left goes up one. If it, the digit to the left, is also at 9, it rolls back to 0 and the digit to its left goes up one. Etc..

Binary is just a different numbering system. Instead of getting the numbers 0-9, it just gets 0 and 1. So.. Counting to 5 in binary goes:

0001
0010
0011
0100
0101

Hexadecimal (0-9 plus A-F) and octal (0-7) are also just other numbering systems. It's all the same numbers but the way they read out - the characters you use to represent some quantity - is different.

Because binary is just 0's and 1's, there's some extra math things you can do that don't make as much sense in other systems. Like ~, the "not" operator, flips all the 0's to 1's and all the 1's to 0's.

An OR operation takes two numbers and, for each digit, results in a 1 if either value is 1 and a 0 if both are 0.. So:

0100 OR
1110 =
1110

Similar, an AND operator returns a 1 if *both* digits are 1 and a 0 if either are 0:
0100 AND
1110 =
0100

Read the above a few times, if needed. Once it finally clicks into place, you'll laugh that you didn't get it before. Really - everybody does.

After that, you can hopefully read more on what others talk about above and it will make a bit more sense. It's just numbers and math..

Here's one primer on binary numbers:
http://www.lyzrdstomp.com/binary/binprime.html?