Aritmética digital
A informação processada por circuitos lógicos e unidades como flip-flops, é sempre booleana, ou seja, informações que podem ser representadas com algarismos binários. Portanto, torna-se necessária a definição de operações matemáticas (aritméticas) entre valores binários, da mesma forma como fazemos na base decimal.
Adição
A operação básica de adição, seja na base decimal, binária ou qualquer outra, segue basicamente o mesmo algoritmo. Iniciando pela operação já conhecida na base decimal:
A operação inicia com a soma dos dígitos (algarismos) menos significativos (LSD), no exemplo acima os algarismos 6 e 1, que resulta o número 7. Em seguida, faz-se a soma dos próximos dígitos, no caso o 7 e 6. Essa soma resulta no número 13, que ultrapassa o valor máximo que pode ser representado por um algarismo decimal (que é 9). Assim, no segundo dígito menos significativo, o resultado será 3 e o valor de 1 (que representa 10 vezes esse algarismo) é levado para o próximo conjunto de dígitos. Esse número, em inglês, é chamado de carry (vai um, em português). Esse número é, então, somado com os outros algarismos do próximo dígito.
Esse algoritmo é válido também para outras bases numéricas, como a binária. A adaptação que deve ser feita é a condição do “vai um”, ou carry, que será de uma unidade quando o resultado da soma ultrapassar o valor máximo representado pela base (1 para a binária, 15 para a hexadecimal, etc). Como exemplo, façamos a operação abaixo seguindo os mesmos passos:
Começando novamente pelo LSB, 1 + 0 = 1, que será o LSB do resultado. Passando para o dígito seguinte, 1 + 1 = 0 + carry para dígito seguinte. A operação no dígito seguinte será 1 (carry) + 0 + 1 = 0 + carry para dígito seguinte. Como os números somados só possuem 3 bits, o resultado terá um quarto, de valor 1.
Subtração
O algoritmo de subtração para números binários também é idêntico ao usado em números de base decimal. Nesse caso, ao invés do número de carry, existe a figura do “pedir emprestado” do algarismo seguinte mais significativo.
Logo, existem quatro possíveis situações em uma subtração binária:
Para ilustrar a idéia, analise a operação abaixo:
Números com sinal
Apesar da adição e subtração com números binários serem operações simples, aplicações práticas exigem o uso de números inteiros, e não somente números naturais. Por isso, é necessário definir uma representação de números negativos em base binária.
O padrão mais simples é o uso de um bit de sinal, mantendo o restante dos algarismos sem modificação. Assim, um número binário de 7 bits, por exemplo, terá o MSB para representar o sinal e os 6 bits restantes para representar a magnitude do número.
Por convenção, o bit de sinal assume o valor 0 para representar um sinal positivo, e o valor 1 para representar um sinal negativo. Nessa representação, uma palavra de 8 bits é capaz de representar números de - 12710 a 12710.
Apesar da simplicidade, o uso de bit de sinal (sem modificar o restante dos bits) não é a forma mais usual de representar números binários negativos. A forma mais comum é chamada de complemento de 2.
Para representar um número negativo nessa forma, toma-se dois passos sequenciais. Primeiro, transforma-se o número em seu complemento de 1, que representa simplesmente a inversão de cada um dos seus bits. O segundo passo é somar uma unidade (binária) ao complemento de 1.
Exemplo: represente o número 0101101 (-4510) em complemento de 2.
Em primeiro lugar, invertemos todos os algarismos do número, resultando em seu complemento de 1, em seguida soma-se 1 ao resultado. Logo:
0 1 0 1 1 0 1 (número original) 1 0 1 0 0 1 0 (complemento de 1) + 1 (soma 1) 1 0 1 0 0 1 1
Repare que, para representar o módulo do número (sem o sinal), usa-se o MSB igual a 0, e como resultado (o número negativo), o valor do MSB é 1. Dessa forma, mantem-se o padrão do MSB igual a 0 para números positivos e 1 para números negativos.
Caso tenhamos números binários representados em palavras com um número de bits maior que o necessário para a representação numeral, o procedimento acima se mantém. Por exemplo, a representação do número -9 em uma palavra de 8 bits será:
0 0 0 0 1 0 0 1 1 1 1 1 0 1 1 0 + 1 1 1 1 1 0 1 1 1
Novamente, se o número for positivo, a palavra binária começará (MSB) com o valor zero, se o número for negativo, começará com o valor 1. O procedimento acima pode ser aplicado a palavras binárias de quaisquer tamanhos.
Considerando novamente palavras de 8 bits (1 Byte), com a representação simples de bit de sinal, é possível representar números de -127 a 127, que somam 255 possíveis valores, e não 256 como tínhamos com números sem sinal. Isso se deve ao fato de o número 10000000, que tecnicamente seria -0, não existe matematicamente, e por isso é uma palavra binária inexistente.
Na representação de complemento de 2, esse número existe. Para saber sua magnitude, basta efetuar o algoritmo no sentido inverso:
Subtraindo 1 do número: 1 0 0 0 0 0 0 0 - 1 0 1 1 1 1 1 1 1 Aplicando o complemento de 1: 1 0 0 0 0 0 0 0
que representa o número +128. Portanto, a representação binária em complemento de 2 para palavras de 8 bits, pode representar números de -128 a +127, totalizando 256 possibilidades.
Analisando o complemento de 2 como uma operação, podemos aplicá-la para “negar” um número, ou seja, multiplicar por -1.
Exemplo: o número 910 representado em 1 Byte é 00001001. Multiplicar por -1 resulta em -910,
representado por 11110111, que é o complemento de 2 do número original. Multiplicar -910 por -1,
resulta no número 910, que na base binária é a aplicação do complemento de 2 em -910:
1 1 1 1 0 1 1 1 (-910)
0 0 0 0 1 0 0 0 (complemento de 1) + 1
0 0 0 0 1 0 0 1 (910)
Adição e subtração em complemento de 2
A aritmética envolvendo números binários na forma de complemento de 2 segue as mesmas regras apresentadas anteriormente, sem alteração. O único cuidado que deve ser tomado é o uso de uma palavra binária que comporte o padrão estabelecido para o MSB, que indicará o sinal do número. Exemplo: Somar os números 410 e 910 na forma de complemento de 2.
0 0 1 0 0 (410)
0 1 0 0 1 (910)
0 1 1 0 1 (1310)
Repare que o número 910 recebeu um algarismo 0 no MSB, para manter o padrão citado
anteriormente.
A subtração de dois números decimais equivale a somar os dois números, multiplicando o segundo por -1, ou seja, a operação 9 – 4 equivale a 9 + (-4). Na base binária, esse raciocínio pode ser implementado, contando que o número negativo esteja na forma de complemento de 2, não sendo possível fazer a mesma operação usando a representação simples de bit de sinal explicada no início. Exemplo: Fazendo a operação 9 – 4, temos
0 1 0 0 1 (910)
1 1 1 0 0 (-410)
1 0 0 1 0 1 (510)
Note que na soma acima, o resultado final apresenta um bit de carry como MSB. Como a palavra binária considerada é de 5 bits, esse sexto bit é desprezado. Se fizermos com uma palavra binária de 8 bits, o resultado será o mesmo:
0 0 0 0 1 0 0 1 (910)
1 1 1 1 1 1 0 0 (-410)
1 0 0 0 0 0 1 0 1 (510)
1 1 1 1 0 1 1 1 (-910)
1 1 1 1 1 1 0 0 (-410)
1 1 1 1 1 0 0 1 1 (-1310)
Novamente, como a palavra binária é de 8 bits, o nono bit de carry é desprezado.
Com as demonstrações acima, fica claro que o uso de complemento de 2 para representação de números binários com sinal é mais utilizado que a forma simples de bit de sinal, pois facilita as operações aritméticas de soma e subtração de números pertecentes ao conjunto dos inteiros.
Overflow
Um problema presente na aritmética de números binários decorre da limitação oferecida pelo número de bits das palavras binárias. Matematicamente, essa limitação não influencia a operação, pois mais dígitos podem ser criados na resolução da operação, entretanto, em aplicações práticas de sistemas digitais, o número de bits para a representação binária de números é limitado pelo número de flip-flops usados nos registradores, e essa limitação resulta no fenômeno chamado overflow. Esse fenômeno é fácil de compreender analisando o número de bits necessários para representar as parcelas de uma operação, e a quantidade de bits necessários para representar o resultado.
Por exemplo, ao somar duas palavras binárias de 1 Byte que representam números naturais (sem sinal), cada parcela pode representar 256 possíveis valores, de 0 a 255. A operação, portanto, 128 + 200 = 328, em binário seria:
1 0 0 0 0 0 0 0 (12810)
1 1 0 0 1 0 0 0 (20010)
1 0 1 0 0 1 0 0 0 (32810)
Logicamente que o resultado não pode ser representado por apenas 1 Byte. Caso tenhamos apenas essa palavra para armazenar o resultado, ele seria errôneo, pois teríamos 01001000 (7210).
O mesmo pode ocorrer se usarmos números em complemento de 2. Nesse caso, os possíveis valores em palavras de 1 Byte seriam de -128 a 127. A operação, por exemplo, 100 + 50 seria:
0 1 1 0 1 0 0 0 (10010)
0 0 1 1 0 0 1 0 (5010)
1 0 0 1 1 0 1 0 (-10210)
Novamente, o resultado é errado, visto que o esperado era o numeral 150, que não pode ser representado por um único byte com sinal.
Multiplicação
Assim como foi feito na adição de números binários, onde o algoritmo de adição usado para a base decimal foi usada sem alteração, a multiplicação de números binários também utiliza o mesmo algoritmo padrão para a base decimal.
O fato de números binários serem representados por somente dois tipos de algarismos (0 e 1), o algoritmo da multiplicação fica, contudo, mais simples.
A multiplicação começa multiplicando o LSB do multiplicador (número de baixo). Se o bit for 1, repete-se o multiplicando, se ele for zero, é colocada uma palavra inteira igual a zero. O mesmo é feito com o próximo bit mais significativo, lembrando que o resultado deve ser deslocado de um algarismo (bit). O procedimento é repetido quantas vezes forem os números de bits da palavra das parcelas.
Ao final, o resultado final é a soma de todos os produtos parciais. Note que o resultado final da multiplicação terá, provavelmente, mais bits que cada uma das parcelas, por isso, é comum que em operações de multiplicação, sejam usadas palavras para armazenar o resultado, com o dobro de tamanho das parcelas multiplicadas.
Como os circuitos usados para realizar a soma de números binários, é geralmente construído para somar apenas duas parcelas, pode-se implementar a multiplicação acima, somando os produtos
parciais a medida que eles são gerados. O exemplo abaixo ilustra esse conceito. 1 0 0 1 x 1 0 1 1 bit 0 (LSB) = 1 0 0 0 0 1 0 0 1 bit 1 = 1 + 0 0 0 1 0 0 1 0 0 0 1 1 0 1 1 bit 2 = 0 + 0 0 0 0 0 0 0 0 0 1 1 0 1 1 bit 3 = 1 + 0 1 0 0 1 0 1 1 0 0 0 1 1
A multiplicação onde um ou os dois operando é negativo (complemento de 2), o sinal deve ser considerado antes da multiplicação, pois o algoritmo não funciona diretamente para números negativos.
Dessa forma, quaisquer operandos negativos devem ser representados pelo seu módulo (valor absoluto), que é positivo, para então aplicar o algoritmo acima. O resultado deve ter o sinal equivalente, respeitando as regras matemáticas. Exemplo: ache o resultado da multiplicação de 0111 por 1110.
Divisão
Novamente o algoritmo usado para a divisão de números na base decimal, com a simplificação que os resultados parciais só podem ser 0 ou 1. Acompanhe o exemplo abaixo:
1 0 0 1 |_0 0 1 1 - 0 1 1 1 1
0 0 1 1 - 0 0 1 1 0 0 0 0
Como na multiplicação, o algoritmo acima não funciona com números negativos em complemento de 2, nesses casos, deve-se usar seus valores absolutos e respeitar as regras matemáticas com relação ao sinal do resultado.
