[INFO] Bitsums and Operators

About:
This tutorial is meant for beginner scripters from amxx. This will teach you on how to use bitsum operators and show some advantages over boolean storage arrays!

What is a bitsum?
A bitsum is based on the way memory works. If we think, the memory chip containes cells (bits) that can hold 2 infos: 1 and 0. To store a number in one byte (byte = 8 bits) here is how to do it:
"8" (normal number) = "00001000" (memory number [1 byte])

How does a bitsum work?
Well the idea is that bitsums allow to control the position that we want to set it to 1. And we can check wether that position has 1 or 0.

What operators do I have, and what do they mean?
I will give an example for each operator:

PHP Code:

Operator: | first_byte = "10010001" second_byte = "01010001"
first_byte | second_byte = "11010001"  

So basically this operator works like the logical one || but it does the operation on each bit!

Code:

|     1      0
1     1      1
0     1      0

PHP Code:

Operator: & first_byte = "10010001" second_byte = "01010001"
first_byte & second_byte = "0001001"  

So basically this operator works like the logical one && but it does the operation on each bit!

Code:

&     1      0
1     1      0
0     0      0

PHP Code:

Operator: ^ (Exclusive OR) first_byte = "10010001" second_byte = "01010001"
first_byte ^ second_byte = "1100000"  

So basically this operator works like the logical one ^^ but it does the operation on each bit!

Code:

^    1      0
1    0      1
0    1      0

PHP Code:

Operator: ~ (Complement applies on only one number!) first_byte = "10010001"
~first_byte = "01101110"  

So basically this operator negates every bit! So 0 becomes 1 and 1 becomes 0.

Code:

~1 = 0
~0 = 1

How do normal numbers work?
They are stored in the normal cells by base. So they are converted from base 10 from base 2. In this case number 9 for example becomse: "00001001". To comvert that number from the cells back to 9 we need to multiply each position with 2 and a power of it! 2^2 = power(2,2) = 4
00001001: 1*(2^0) + 0*(2^1) + 0*(2^2) + 1*(2^3) + 0*(2^4) + 0*(2^5) + 0*(2^6) + 0*(2^7) = 1 + 8 = 9

How can I easily create a bitsum?
Well you need 2 operators: << and >>, or if you don't want to use those operators you can easily create one by using elements that represent powers of 2.
Example:

PHP Code:

Bitsum "00001111" = 8 | 4 | 2 | 1  

The 2 operators have a special meaning!
"<< x" means that a position of a number is moved by x points to left! Example:

PHP Code:

"00001100" << 1 = "00011000"  

When we convert this to normal number we can see that the normal number was multiplied by 2.
So if we have (1<<3) it would be like 2^3 * 1

The >> operator does the same thing like << but moves x points to right! When using integer variables the numbers disappear.

PHP Code:

"00000111" >> 3 = "00000000"  

So using those 2 operators to create a bitsum we have this:

PHP Code:

Bitsum "00001111" = (1<<3 | 1<<2 | 1<<1 | 1<<0)  

How can I use this in my scripts? 
Well it can be used for insance instead of boolean arrays.

So instead of having this:

PHP Code:

new bool:is_alive[33]  

We have:

PHP Code:

new bitsum_is_alive  

So less memory usage!

Instead of

PHP Code:

if (is_alive[id])
{
}  

We have:

PHP Code:

if (bistum_is_alive & (1<<id))
{
}  

Instead of this

PHP Code:

is_alive[id] = true  

PHP Code:

is_alive[id] = false  

We will have this:

PHP Code:

bitsum_is_alive |= (1<<id)  

PHP Code:

bitsum_is_alive &=  ~(1<<id)  

The good thing is that you can extend the limit of the 32 slots that a simple number allowes with an array so that we can have more slots.
Ex:

PHP Code:

new holder[4] // holder has 4 * 32 places where we can store the true/false value
// Here are the functions that allow you to manipulate them!

// Here we make the desired slot true save(x)
{
    holder[x / 32] |= 1 << (x % 32);
}
// Here we check the desired slot  exists(x)
{
    return holder[x / 32] & 1 << (x % 32);
}
  // Here we remove the desired slot  remove(x)
{
    holder[x / 32] &= ~(1 << (x % 32))
}  

As you can see it is harder to use bitsums but they have better results when it comes to low memory usage!
Hope that my english was fine!