Lógica binária

Origem: Wikipédia, a enciclopédia livre.
Ir para: navegação, pesquisa
Question book.svg
Esta página ou secção não cita nenhuma fonte ou referência, o que compromete sua credibilidade (desde junho de 2010).
Por favor, melhore este artigo providenciando fontes fiáveis e independentes, inserindo-as no corpo do texto por meio de notas de rodapé. Encontre fontes: Googlenotícias, livros, acadêmicoScirusBing. Veja como referenciar e citar as fontes.

A lógica binária, ou bitwise operation é a base de todo o cálculo computacional. Na verdade, são estas operações mais básicas que constituem todo o poderio dos computadores. Qualquer operação, por mais complexa que pareça, é traduzida internamente pelo processador para estas operações.

Operações

NOT[editar | editar código-fonte]

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 saida:

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

AND[editar | editar código-fonte]

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 saida:


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

OR[editar | editar código-fonte]

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 saida:

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

XOR[editar | editar código-fonte]

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[editar | editar código-fonte]

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 deslocalmento 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(10):

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[editar | editar código-fonte]