Lógica binária

Na programação de computadores, a lógica binária, ou bitwise operation opera em um ou mais padrões de bits ou números binários no nível de seus bits individuais. É uma ação rápida e simples, diretamente suportada pelo processador, e é usada para manipular valores para comparações e cálculos.

Em processadores simples de baixo custo, normalmente, as operações bit a bit são substancialmente mais rápidas que a divisão, várias vezes mais rápidas que a multiplicação e algumas vezes significativamente mais rápidas que a adição. [Esclarecimentos necessários] Enquanto os processadores modernos geralmente executam adição e multiplicação tão rápido quanto as operações bit a bit devido a Com seus pipelines de instruções mais longos e outras opções de design de arquitetura, as operações bit a bit geralmente usam menos energia devido ao uso reduzido de recursos.

NOT

O operador unário NOT, ou negação binária resulta no complemento do operando, ou seja, será um bit '1' se o operando for '0', e será '0' caso contrário, conforme podemos confirmar pela tabela de verdade, A é o bit de entrada e S é o bit-resposta, ou bit de saída:

 |  A  |  S  |
 +-----+-----+
 |  0  |  1  |
 +-----+-----+
 |  1  |  0  |
 +-----+-----+

AND

O operador binário AND, ou conjunção binária devolve um bit 1 sempre que ambos operandos sejam '1', conforme podemos confirmar pela tabela de verdade, onde A e B são bits de entrada e S é o bit-resposta, ou bit de saída:

 |  B  |  A  |  S  |
 +-----+-----+-----+
 |  0  |  0  |  0  |
 +-----+-----+-----+
 |  0  |  1  |  0  |
 +-----+-----+-----+
 |  1  |  0  |  0  |
 +-----+-----+-----+
 |  1  |  1  |  1  |
 +-----+-----+-----+

OR

O operador binário OR, ou disjunção binária devolve um bit 1 sempre que pelo menos um dos operandos seja '1', conforme podemos confirmar pela tabela de verdade, onde A e B são os bits de entrada e S é o bit-resposta, ou bit de saída:

 |  B  |  A  |  S  |
 +-----+-----+-----+
 |  0  |  0  |  0  |
 +-----+-----+-----+
 |  0  |  1  |  1  |
 +-----+-----+-----+
 |  1  |  0  |  1  |
 +-----+-----+-----+
 |  1  |  1  |  1  |
 +-----+-----+-----+

XOR

O operador binário XOR, ou disjunção binária exclusiva devolve um bit 1 sempre que o número de operandos iguais a 1 é ímpar, conforme podemos confirmar pela tabela de verdade:

 |  B  |  A  |  S  |
 +-----+-----+-----+
 |  0  |  0  |  0  |
 +-----+-----+-----+
 |  1  |  0  |  1  |
 +-----+-----+-----+
 |  0  |  1  |  1  |
 +-----+-----+-----+
 |  1  |  1  |  0  |
 +-----+-----+-----+

Shift

O deslocamento de bits é uma operação elementar de lógica binária que consiste na rotação de um conjunto de bits (como um byte ou word, por exemplo). Devido às características do sistema binário, existe correspondência directa com as seguintes operações matemáticas:

• multiplicação (por 2) do operando - caso o deslocamento seja feito para a esquerda;
• divisão inteira (por 2) do operando - caso o deslocamento seja feito para a direita.

Considere-se o número 77 em decimal e o resultado do deslocamento de bits para a esquerda:

Em binário: 0100 1101 << 1 = 1001 1010
Em decimal:    77      x 2 =    154

Considere-se agora o deslocamento de bits para a direita, para o mesmo valor 77₍₁₀₎:

Em binário: 0100 1101 >> 1 = 0010 0110
Em decimal:    77      / 2 =    38

Em arquitecturas x86 o bit excluído é colocado na flag CF (Carry Flag), que corresponde ao resto da operação de divisão, pelo que esse bit estaria a 1 no exemplo acima.

Já em DSPs, como por exemplo os da família Texas Instruments TMS320C2x, há instruções de shift e de rotate. O shift causam um deslocamento simples dos bits, para a esquerda (instrução SFL) ou para a direita (instrução SFR), usando o carry. Já o rotate "roda" os bits através do carry para a esquerda (instrução ROL) ou para a direita (instrução ROR).

Ver também

• Álgebra booleana