Битовые операции

1- Bitwise

В цифровом компьютерном программировании. Операция  bitwise раотает на одном или нескольких двоичных цифрах (binary numerals), или строках похожие на двоичные цифры. Это простая и быстрая операция, которая поддерживается напрямую процессором (processor). Обычно операции  bitwise намного быстрее по сравнению с умножением, делением, иногда значительно быстрее, чем сложение. Вычисления  bitwise используют меньше энергии, так как он использует меньше ресурсов.
Имеется 7 оперций  bitwise:
Оператор Название Описание
& AND Если оба bit являются 1, возвращается значение 1, если наоборот то возвращает 0.
| OR Если один из двух bit является 1, возвращается значение 1, если наоборот то возвращает 0.
^ XOR Если два bit отличаются, возвращается значение 1, если наоборот то возвращает 0.
~ NOT Инвертирует все bit, 0 становится 1 и 1 становится 0.
<< Zero fill left shift Смещает все  bit влево.
>> Signed right shift Смещает все bit вправо, кроме первого bit.
>>> Zero fill right shift Смещает все  bit влево.

Bitwise AND

Когда выполняется  bitwise AND на паре  bit, он возвращает 1, если оба 2 bit являются 1, если наоборот, то возвращает 0.
Пример с 1 bit:
Operation Result
0 & 0 0
0 & 1 0
1 & 0 0
1 & 1 1
Пример с 4 bit:
Operation Result
1111 & 0000 0000
1111 & 0001 0001
1111 & 0010 0010
1111 & 0100 0100

Bitwise OR:

Когда выполняется один  bitwise OR на паре  bit, он возвращает 1, если один из bit является 1, если наоборот то возвращает 0.
Пример с 1 bit:
Operation Result
0 | 0 0
0 | 1
1 | 0 1
1 | 1 1
Пример с 4 bit:
Operation Result
1111 | 0000 1111
1111 | 0001 1111
1111 | 0010 1111
1111 | 0100 1111

Bitwise XOR

Когда выполняется один  bitwise XOR на паре bit, он возвращает 1 если все  bit разные, если наоборот возвращает 0.
Пример с 1 bit:
Operation Result
0 ^ 0 0
0 ^ 1
1 ^ 0 1
1 ^ 1
Пример с 4 bit:
Operation Result
1111 ^ 0000 1111
1111 ^ 0001 1110
1111 ^ 0010 1101
1111 ^ 0100 1011

Bitwise NOT

Когда используется один  Bitwise NOT он инвертирует все bit. 1 становится 0, и 0 становится 1.
Пример с 1 bit:
Operation Result
~ 0 1
~ 1 0
Пример с 4 bit:
Operation Result
~ 0000 1111
~ 0001 0001
~ 0010 1101
~ 1100 0011

2- Операция Bitwise на числах

Разные языки могут иметь несколько видов данных для представления чисел.
  • Java: byte, short, int, long, double.
  • C#: byte, sbyte, short, ushort, int, uint, long, ulong, float, double
  • Javascript: double
  • .....
Javascript хранит числа как числа с плавающей точкой 64 bit (64 bits floating point numbers). Но операции  bitwise выполненные на целых числах 32 bit. Другие языки как Java, C#,.. операции  bitwise так же выполняются на целых числах 32 bit.
Поэтому перед тем как выполнить операцию  bitwise с числами вам нужно конвертировать каждое число в последовательность из 32 двоичных чисел.
Base 10 Base 2 32 bits
5 101 00000000000000000000000000000101
218 11011010 00000000000000000000000011011010
В  Javascript метод  toString(base) помогает вам поменять любое число из десятичной системы (base 10) в другую.
toString-base-example.js (Javascript)
let a = 8;


// Base 2 string.
console.log( a.toString(2) );// 1000

// Base 8 string
console.log( a.toString(8) ); // 10

// Base 16 string
console.log( a.toString(16) ); // 8


let b = 218;


// Base 2 string.
console.log( b.toString(2) );// 11011010

// Base 8 string
console.log( b.toString(8) ); // 332

// Base 16 string
console.log( b.toString(16) ); // da

 
Пример:
Decimal Binary
5 00000000000000000000000000000101
1 00000000000000000000000000000001
5 & 1 = 1 00000000000000000000000000000001
5 | 1  = 5 00000000000000000000000000000101
5 ^ 1  = 4 00000000000000000000000000000100
~ 5    = -6 11111111111111111111111111111010
Примечание: В 32 bit, первый  bit используется для определения знака (sign) числа, если данный  bit является 1, соответствует знаку минус ( - ), если данный  bit является 0 соответствует знаку плюс ( + )

Bitwise Left Shift (<<)

Decimal Binary
5 00000000000000000000000000000101
5 << 1  = 10 00000000000000000000000000001010
5 << 2  = 20 00000000000000000000000000010100
Оператор  Bitwise Left Shift ( << ) может изменить знак (sign) числа.
(Javascript code)
console.log( 1073741824 << 1); // -2147483648

console.log( 2684354560 << 1); // 1073741824

Bitwise Right Shift (>>)  [Unsigned Right Shift]

Decimal Binary
29 00000000000000000000000000011101
29 >> 1  = 14 00000000000000000000000000001110
29 >> 2  = 7 00000000000000000000000000000111
Оператор  Bitwise Right Shift ( >> ) не изменяет знак числа, так как первый  bit не перемещен.

Bitwise Right Shift (>>>) [Zero fill right Shift]

Оператор  Bitwise Right Shift ( >>> ) может изменить знак числа.
(Javascript Code)
console.log( -1073741824 >>> 1); // 1610612736

console.log( 1073741824 >>> 1); // 536870912

3- Для чего используется Bitwise?

Вычисления  bitwise поддерживаются напрямую процессором (processor) компьютера, поэтому он работает очень быстро. Ниже я перечисляю некоторые примеры использования данных вычислений.
Используйте операторы  bitwise на  String (characters) на языках  Java, C#, C/C++ ... Примечание: некоторые языки как Javascript не поддерживает вычисления  bitwise с видом  String.
Конвертировать прописную букву (Uppercase) в строчную (Lowercase):
// Rule: x | ' '

('A' | ' ') ==> 'a'
('B' | ' ') ==> 'b'

('a' | ' ') => 'a'
Конвертировать строчную букву (Lowercase) в прописную (Uppercase):
// Rule: x & '_'


('a' & '_') ==> 'A'
('b' & '_') ==> 'B'

('A' & '_') ==> 'A'
Переменить прописную букву в строчную, строчную в прописную:
// Rule: x ^ ' '
 
('a' ^ ' ') ==> 'A'
('A' ^ ' ') ==> 'a'
Просмотреть расположение латинских букв ( Latin) (Применяется только к прописным буквам)
// Rule:  x & '?'

'A' & '?'  ==> 1
'B' & '?'  ==> 2
...
'Z' & '?'  ==> 26

// Rule:  x ^ '@'


'A' ^ '@'  ==> 1
'B' ^ '@'  ==> 2
...
'Z' ^ '@'  ==> 26


 
Просмотреть расположение латинских букв ( Latin) (Применяется только к строчным буквам)
// Rule:  x ^ '`'


'a' ^ '`'  ==> 1
'b' ^ '`'  ==> 2
...
'z' ^ '`'  ==> 26

// '`' : binary ( 1100000 ), hex('60'),  chr(96)
Просмотреть расположение латинских букв ( Latin), применяется и к прописным и к строчным буквам:
// Rule:  x & '\u001F'

'A' & '\u001F'  ==> 1
'B' & '\u001F'  ==> 2
...
'Z' & '\u001F'  ==> 26

'A' & '\u001F'  ==> 1
'B' & '\u001F'  ==> 2
...
'Z' & '\u001F'  ==> 26