Fundamentos da Informática

Operações Aritméticas em Binário

No artigo anterior falei das bases de numeração. Neste artigo falarei sobre operações aritméticas em
binário.
É relativamente simples: 1 + 1 = 10!
Bom… acho que uma explicação mais detalhada é melhor
As operações de soma a subtração em binário são muito parecidas com as operações de soma e
subtração convencionais: Soma-se (ou subtrai-se) os 2 números, começando pela direita, se “sobra”
um numero, coloca ele no próximo algorismo (ou, na subtração, se pede “emprestado”):
Fazendo somas decimais passo a passo:
49 + 28.
Soma-se o 9 com o 8. O resultado é 17. Como 17 é maior que 10, “guardamos” o que sobra para
soma dos próximos algorismos.
Em seguida, soma-se o 4 e o 2. O resultado é 6. Como na soma dos algorismos anterior havia
“sobrado” um numero, adiciona-se este numero ao 6, ou seja, 6+1=7. O resultado é 77.
A subtração é mesma coisa:
23 – 15.
Calcula-se 3 – 5. Como 3 é menor que 5, ele “pede emprestado” um numero para o 2. Então
calcula-se 13-5, que é 8.
Na subtração do segundo algorismo, o 2, que “emprestou” para o 3, passou a ser 1. Então, 1 – 1 = 0.
O resultado da conta é 8.
Não fiz desenho pois todo mundo já deve ter aprendido isto na escola!
Em binário, há somente 2 dígitos: 0 e 1. Porém a soma funciona da mesma forma que na álgebra
normal. Devemos lembrar sempre que:
0+0 = 0
0+1 = 1
1+0 = 1
1+1 = 10.
Repare no ultimo calculo: 1+1 = 10. O “1″ do 10 é justamente o que sobra do calculo de 1+1. Este
“1″ que sobrou é chamado de “Carry”.
Um ponto a ser observado é que em binário é comum ocorrer um verdadeiro “Efeito dominó” de
sobras durante a soma. O que quero dizer com efeito “dominó”: Em decimal, a soma 9999 +1,
como 9+1 = 10, na soma do primeiro algorismo vai sobrar um valor, que deve ser acrescentado ao
segundo algorismo. Porém, esta soma também causará uma sobra, que será adicionada ao terceiro…
que também causará a sobra que deverá ser adicionada ao quarto algorismo, que também sobrará e,
finalmente, um quinto algorismo deverá ser adicionado, gerando a resposta 10000. Como em
binário só temos 2 dígitos, este “efeito dominó” ocorre muito frequentemente. Só coloquei este
alerta pois já vi casos de pessoas que, realizando exercícios, ao somar em binário acharam que o
calculo estava errado por causa do efeito dominó.
continuando:
O procedimento da soma é igual na soma decimal, porém, com só 2 valores possíveis: 0 e 1.
exemplo:
10101001 + 00110011 = 11011100

Ta ali a soma. Os numeros em vermelhos são as “sobras” da soma dos algarismos anteriores.
Exatamente como a soma convencional, porém usando só 0 e 1!
Se no ultimo algorismo também “sobrasse” 1, era só colocar mais um algorismo no final, exemplo:
11111111 + 00000001 = 100000000
Nós, humanos, podemos ir adicionando numerosinhos enquanto houver espaço no papel.
Computadores não tem este luxo: Se o computador que realizar a soma que fiz de de 11111111 + 1
não conseguir trabalhar com mais de 8 bits, o resultado seria 00000000 e um erro de overflow!.
(Overflow é quando o resultado de um calculo é muito grande para a máquina). Se a soma fosse
11111111 + 00000010, o resultado seria 00000001 com erro de overflow. Efetivamente, 255 + 2 = 1
com aviso de erro de overflow.
É importante lembrar que, se estamos trabalhando com números de 8 bits, serão sempre 8 bits a
resposta. Se estivermos trabalahndo com numeros de 16bits, a resposta será sempre 16bits! Se o
resultado ultrapassar o numero de bits, então ocorre um overflow.
O maior numero possivel de representar dado um determinado numero de bits binários é dada pela
seguinte equação:
(2^N)-1. Aonde N é o numero de bits. Para 8 bits, o valor é( 2^8)-1 ou seja: 256-1, ou 255. Valores
entre 0 e 255 são válidos.
Não vou falar de subtração agora, pois preciso falar de números negativos e um fato sobre
computadores.
Nós, humanos, sabemos diferenciar um numero positivo de um numero negativo porque, no numero
negativo, existe um sinal de “menos”(-) antes do numero. Lembra quando eu disse que
computadores só conhecem 0 e 1? então… eles não conhecem numeros com sinais de menos…
Se vocês se lembram da escola, 5 + (-3) é o mesmo que 5 – 3, e, obviamente, 5 -3 é o mesmo que 5
+ (-3). Ou seja: A subtração de um A por um numero B é o mesmo que somar A com o B negativo.
Esta propriedade matemática também se aplica em binário, e por isto, computadores não sabem
subtrair! Eles só somam. Para subtrair, A de B, eles transformam B em um numero negativo,e em
seguida, somam. Mas, como computadores sabem quando um numero é negativo?
Quando a infomática surgiu, um número negativo era o mesmo numero positivo porém invertido: O
numero dez, em binário, é 00001010. O dez negativo é 11110101. O sistema diferencia um numero
positivo de um negativo pelo “1″ no bit mais significaivo (o mais à esquerda). Este método,
chamado de “Complemento de um”, funciona bem, o problema é que existe uma ambiguidade: E o
numero zero? 00000000 e 11111111 represemtam 0.
E isto é um GRANDE problema, pois não existe “Zero negativo”.
Para solucionar isto, foi criado o “Complemento de dois”, que funciona assim:
Sempre que ocorre uma conversão de positivo para negativo ou vice versa, além da inversão de
digitos, ocorre a soma de 1 ao valor resultante.No caso, o numero zero ficara 11111111 + 1 =
00000000.
Então, se dez positivo é 00001010, dez negativo é 11110101 + 1 = 11110110.
Para transformar dez negativo em dez positivo, basta repetir o processo: 11110110 -> 00001001 + 1
= 00001010.
Vamos testar: dez positivos somados com dez negativos, deve ser zero (10 + (-10)) = 10-10 = 0.
00001010 + 11110110 = 100000000. O 1 que sobrou é descartado pelo sistema. Isso funciona
sempre. O sistema faz testes para detectar Overflows durante a soma. O teste é simples: Se os 2
ultimos bits de “vai um” (Carry) forem 1 e 1 ou 0 e 0, a troca de sinal ocorreu de forma válida. Se
for 0 e 1 ou 1 e 0, então ocorreu um overflow.
Quando se lida com complemento de 2, o intervalo numérico representado dado um numero de bits
é o seguinte:
De -2^(N-1) até (2^(N-1))-1. Ou seja: Para 8 bits, o intervalo vai de -2^(8-1) até (2^(8-1))-1, que é o
mesmo que -2^7 até (2^7)-1, que é o mesmo que -128 até 127.
Na wikipedia, em ingles, tem uma explicação completa e detalhada sobre o complemento de 2.
Como foi possivel perceber, com 1 byte é possivel representar números entre 0 e 255, ou entre -128
e 127.
Como o sistema sabe quando um byte deve ser considerado como sendo entre 0 e 255 ou -128 e
127? Simples: Ele não sabe. O programa em execução é o responsável por definir se o byte é
Unsigned (entre 0 e 255) ou Signed (entre -128 e 127).
Espero que este texto não tenha ficado muito confuso – foi o melhor que eu pude fazer para este
tópico. O próximo artigo será mais legal: Falará sobre operações booleanas : And, Or, Xor, Not
Essa entrada foi postada em 0, 7 \07\UTC janeiro \07\UTC 2009 às 12:00 pm sob a(s) categoria(s)
Fundamentos da informatica. Você pode acompanhar as respostas desse post através do RSS
2.0feed. Você pode responder, ou rastrear de seu próprio site.
1.
• Arquivos
• abril 2009
• janeiro 2009
• dezembro 2008

• Categorias
• Criptografia
• Fundamentos da informatica
• Para usuários domésticos
• Redes
• Sem categoria
Theme: Contempt by Vault9.
Blog no WordPress.com.

Blog de segurança de informação

• Início
• Sobre
Fundamentos da Informática – Circuitos Lógicos – 2
Neste artigo vou demonstrar circuitos simples, como os somadores. O objetivo não é falar de
somador, mas sim mostrar um pouco da lógica da coisa.
Todo mundo sabe que, em binário, quando estamos trabalhando somente com 1 bit de precisão, 1+1
= 0. Mas, como fazer um circuito que calcule isto?
Se você leu os artigos anterior, aprendeu que a soma binária ocorre bit a bit, e o overflow é
adicionado ao próximo elemento.
Um circuito somador precisa somar 2 valores binários. É necessário ainda, que o sistema avise
quando ocorre um overflow. Considerando que nosso sistema é capaz de trabalhar apenas com
valores de 1 bit (1 bit em cada uma das duas entradas, 1 bit de saida), vamos analizar a soma:
0+0=0, e não há overflow.
1+0 (ou 0+1), = 1, e não há overflow.
1+1=10. Como 10 são 2 bits, há overflow: 1+1=0 com overflow.
Logo,nosso circuito deve ser capaz de realizar a soma e avisar a ocorrência de um overflow.
Um desenho que se adequa as nossas necessidades é este:

Observe: 0+1:

E agora 1+1:
Este circuito realiza a soma de forma correta. Porém, ele soma somente 2 bits, ele não é muito util.
Seria interessante se desse para construir um circuito que, além dos 2 valores de entrada, recebesse
um terceiro valor de entrada. Se ligar-mos este terceiro valor de entrada na saida de overflow de
outro circuito somador, teremos um circuito de soma genérico – basta apenas cascatear os circuitos
para somar vários bits. E é isto que iremos fazer agora:
Um circuito somador completo possui esta caracteristica, e pode ser representado da seguinte
forma:

Por questões de espaço não vou mostrar cada um dos estados possiveis.
A questão é a seguinte: Este somador soma 2 valores de 1 bit, emitindo o resultado com 1 bit e se
houve ou nao overflow. Ele também possui uma terceira entrada, que representa o valor do
“Overflow Anterior”. Se ligar-mos em série vários cirtuitos destes, podemos somar 2 valores de
mais de 1 bit, como o seguinte circuito, que soma 2 valores (A e B) de 2 bits cada:
O desenho ficou um pouco confuso pois eu fui obrigado a reduzir para caber no post.
Para facilitar, colocarei 2 exemplo: A soma de 01 + 01:

Observe que o valor de Overflow é transferido para a entrada de overflow do proximo circuito –
exatamente como se faz na soma manual. Mas, e quando 11+01 for somado? O resultado é 100, que
é muito grande para a precisão de 2 bits que este circuito possui. Nesta situação, ocorre o seguinte:
Observe que o Overflow passou a ser 1, enquanto o resultado 00. Esta soma esta correta.
Para fazer um circuito capaz de somar 3, 4, 10, 1000, 10209193123 bits, basta ir interligando os
circuitos.
É importante lembrar que, o mesmo circuito de soma, é usado para subtração – a subtração é a a
mesma operação de soma, porém com o segundo valor multiplicado por -1 (ou seja: 2 – 5 é o
mesmo que 2 + (-5)).
O logisim possui uma função pré-pronta para representar o somador (há também para a subtração,
multiplicação e divisão), o simbolo é:

O mesmo circuito do somador de 2 bits pode ser feito da seguinte forma:

Que é bem mais simples de entender! O logisim possui a capacidade de fazer somadores de 2, 3, 4,
até 32 bits nativamente. Se usarmos a técnica de combinação mostrada acima, é possivel criar
circuitos para calcular qualquer quantidade de bits.