Cap 06

6-1
Captulo
SEIS
Multiplicao e Diviso
6. 1 Multiplicao binria (nmeros inteiros positivos)
Em qualquer sistema de numerao, a multiplicao uma forma resumida da soma repetitiva
de uma parcela consigo mesma (o multiplicando) um determinado nmero de vezes (dado
pelo multiplicador). Assim, a multiplicao a x b significa a + a + a + ... + a, onde a
parcela a se repete b vezes. A soma repetitiva levaria entretanto muito tempo para ser
realizada, especialmente para nmeros grandes. Assim, desenvolveu-se (para o sistema
decimal) um mtodo que permitisse realizar a multiplicao de forma mais rpida. Cada
dgito do multiplicador multiplica individualmente o multiplicando e depois as parcelas
intermedirias so somadas. Deve-se notar que cada parcela, alm de ser multiplicada pelo
dgito do multiplicador, tambm multiplicada pelo peso deste dgito:
63
123
189 (63 x 3 x 1)
1260 (63 x 2 x 10)
+ 6300 (63 x 1 x 100)
7749
Para simplificar a notao, assume-se o peso do dgito implicitamente, deixando-se de
escrever os respectivos zeros. No lugar disto, simplesmente desloca-se cada parcela uma
casa decimal para esquerda:
63
123
189 (sem deslocamento: x 1)
126 (um deslocamento: x 10)
+ 63 (dois deslocamentos: x 100)
7749
Esta a forma normal de realizao da multiplicao decimal. A multiplicao binria
realizada exatamente da mesma forma. Observe-se que um deslocamento para a esquerda, em
qualquer sistema de numerao, equivale a multiplicar pela base deste sistema. Assim, em
decimal, para multiplicar por dez simplesmente desloca-se todo o nmero uma casa para a
esquerda e acrescenta-se um zero na posio menos significativa. O mesmo vale para o
sistema binrio quando se quiser multiplicar por dois.
Em binrio a tabela de multiplicao extremamente simples. Note-se que, ao multiplicar-se
por zero, o resultado zero, e ao multiplicar-se um nmero qualquer por um, o resultado
este prprio nmero.
Multiplicando Multiplicador Resultado
0 0 0
0 1 0
1 0 0
1 1 1
6-2
A multiplicao segue o mtodo da multiplicao decimal: analisa-se cada dgito do
multiplicador, da esquerda para direita; multiplica-se o multiplicando por cada um destes
dgitos; desloca-se o resultado intermedirio de cada multiplicao cada vez uma casa a mais
para a esquerda; e finalmente soma-se todas as parcelas, formando o resultado final. Por
exemplo, sejam dois nmeros de seis bits, em representao inteira positiva:
1 1 0 1 1 0
x 1 1 0 0 1 1
1 1 0 1 1 0
1 1 0 1 1 0
0 0 0 0 0 0
0 0 0 0 0 0
1 1 0 1 1 0
+ 1 1 0 1 1 0
1 0 1 0 1 1 0 0 0 0 1 0
Quando um dgito do multiplicador for zero, o resultado da multiplicao intermediria
tambm ser zero. Esta parcela pode ento ser eliminada da soma final, pois no contribui
para o resultado:
1 1 0 1 1 0
x 1 1 0 0 1 1
1 1 0 1 1 0
1 1 0 1 1 0
1 1 0 1 1 0
+ 1 1 0 1 1 0
1 0 1 0 1 1 0 0 0 0 1 0
Para um computador, somar diversas parcelas bem mais complexo do que somar duas
parcelas. Assim, as parcelas intermedirias so somadas a medida em que so formadas:
1 1 0 1 1 0
x 1 1 0 0 1 1
1 1 0 1 1 0
+ 1 1 0 1 1 0
1 0 1 0 0 0 1 0
+ 1 1 0 1 1 0
1 0 0 0 0 0 0 0 0 1 0
+ 1 1 0 1 1 0
1 0 1 0 1 1 0 0 0 0 1 0
No exemplo acima, multiplicou-se dois nmeros de seis bits e obteve-se um resultado em 12
bits. De um modo geral, multiplicando-se um nmero de n bits por outro de m bits
obtm-se um resultado de n+m bits. No caso dos computadores, que trabalham com
nmeros de n bits, a multiplicao produz nmeros de 2n bits. Devido a este fato, nunca
ocorre estouro de representao. Para a multiplicao binria tem-se, at agora, o seguinte
mtodo:
1. Incio: i 0, resultado 0
2. Se o bit de ordem i do multiplicador for zero, ir para 4.
3. Somar o multiplicando ao resultado (resultado resultado + multiplicando)
4. Deslocar o multiplicando para a esquerda (multiplicando multiplicando x 2)
5. Incrementar i de uma unidade (i i + 1)
Se i for menor que o nmero de bits do multiplicador, ir para 2.
Seno, terminar.
6-3
Devido ao fato de trabalhar com um nmero fixo de bits, no to simples para um
computador somar nmeros de comprimentos diferentes. Assim, o mtodo de multiplicao
ainda precisa ser melhor adaptado. Para tanto, devemos observar que:
o bit menos significativo do resultado s afetado pela primeira parcela da soma;
nenhuma outra parcela pode alterar mais este bit.
generalizando, o i-simo bit menos significativo do resultado s afetado pelas
primeiras i parcelas intermedirias. Por exemplo, o segundo bit do resultado s
afetado pelas duas primeiras parcelas; o terceiro bit s afetado pelas trs primeiras
parcelas, e assim por diante.
se uma das parcelas de uma soma deve ser deslocada para a esquerda, o mesmo
resultado obtido deslocando-se a outra parcela para a direita.
Assim, a cada passo da multiplicao, no lugar de deslocar-se o multiplicando para a
esquerda, desloca-se o resultado para a direita. E os bits menos significativos do resultado,
um de cada vez, so armazenados em um elemento especial, pois no sero mais
modificados. Sejam ento M o multiplicando, em n bits; m o multiplicador, tambm em
n bits; R os n bits mais significativos do resultado; r os n bits menos significativos
do resultado; e c o vai-um da soma (carry). Tem-se ento o seguinte mtodo:
1. Incio: i 0, R 0, r 0
2. Se o bit de ordem i de m for zero (m
i
=0), fazer c 0 e ir para 4.
3. Somar M a R (R R + M), c vai-um
4. Deslocar os 2n bits do resultado para direita, usando o vai-um da soma
anterior como novo bit mais significativo do resultado (se no houve soma, usa-
se 0):
( R r ) desl.direita( c R r )
5. Incrementar i de uma unidade (i i + 1)
Se i for menor que n, ir para 2. Seno, terminar.
Sejam por exemplo n = 6, M = 110110, m = 110011. Ento tem-se:
1. i 0, R 000000, r 000000
2. m(0) = 1, continuar em 3
3. R 000000 + 110110 = 110110, c = 0
4. (R r) desl.direita(0 110110 000000) = (011011 000000)
5. i 1; i < 6; ir para 2
3. R 011011 + 110110 = 010001, c = 1
4. (R r) desl.direita(1 010001 000000) = (101000 100000)
5. i 2; i < 6; ir para 2
2. m(2) = 0, c = 0 e ir para 4
4. (R r) desl.direita( 0 101000 100000) = (010100 010000)
5. i 3; i < 6; ir para 2
2. m(3) = 0, c = 0 e ir para 4
4. (R r) desl.direita(0 010100 010000) = (001010 001000)
5. i 4; i < 6; ir para 2
3. R 001010 + 110110 = 000000, c= 1
4. (R r) desl.direita(1 000000 001000) = (100000 000100)
5. i 5; i < 6; ir para 2
6-4
3. R 100000 + 110110 = 010110, c = 1
4. (R r) desl.direita(1 010110 000100) = (101011 000010)
5. i 6; fim. Resultado = 101011000010
O mtodo pode ser melhorado ainda mais. Basta observar-se os seguintes pontos:
1. A rigor, r no necessita ser inicializado com zeros. (No exemplo anterior, basta
substituir o 000000 inicial de r por xxxxxx)
2. Uma vez analisado, um bit do multiplicador no ser mais utilizado (no influencia
mais no resultado) e pode ser descartado.
3. Considerando-se o item (2), para facilitar a anlise dos bits do multiplicador, este
tambm pode ser deslocado para a direita no passo 4. Assim, a anlise ser sempre no
bit menos significativo do multiplicador.
4. Desta maneira, a varivel i somente tem a funo de controlar que o lao seja
executado n vezes. Assim, ao invs de contar para cima de zero at n, pode-se
tambm contar para baixo de n at zero (Observe-se que um teste de zero bem
simples de ser realizado em um computador).
O algoritmo modificado em funo destas observaes pode ser visto a seguir. Sejam m,
M, R, r, n e c definidos como anteriormente.
1. Incio: i n, R 0
2. Deslocar m para a direita, juntamente com o carry. Note-se que o bit menos
significativo de m levado para o carry:
( m c ) desl.direita( m )
Se c = 0, ir para 4.
4. Deslocar os 2n bits do resultado para direita, usando o vai-um da soma
anterior como novo bit mais significativo do resultado (se no houve soma, usa-
se 0 devido ao passo 2):
( R r ) desl.direita( c R r )
5. Decrementar i de uma unidade (i i 1)
Se i no for zero, ir para 2. Seno, terminar. Resultado em (R r)
O resultado expresso em 2n bits. Caso seja desejado um resultado em somente n bits,
deve-se truncar os n bits mais significativos. Neste caso, entretanto, deve-se testar por um
possvel estouro de representao:
Se os nmeros forem representados como inteiros positivos, a truncagem realizada
com sucesso (no h estouro) caso os n bits mais significativos sejam todos iguais a
zero.
Se os nmeros forem representados como inteiros em complemento de dois (mas
positivos), a truncagem realizada com sucesso (no h estouro) caso os n+1 bits
mas significativos sejam todos zero. Ou seja, os n bits mais significativos devem ser
zeros para poderem ser desprezados, e o bit de sinal dos n bits restantes deve ser zero
para o resultado ser positivo.
Para se adaptar s instrues de deslocamento para a direita do Ahmes, o algoritmo deve ser
um pouco modificado. No passo 2, deve ser usada a instruo de SHR (bit mais
significativo recebe zero, e o bit menos significativo vai para o carry). No passo 4, o
deslocamento conjunto de c, R e r deve ser desdobrado em duas instrues de ROR (bit mais
significativo recebe o valor atual do carry, e o bit menos significativo vai para o carry). Com
isto, o algoritmo fica:
6-5
1. Incio: i n, R 0
2. Deslocar m para direita (o bit menos significativo vai para o carry). Se o carry
for zero (c=0), ir para 4.
4. Deslocar os 2n bits do resultado para direita, usando o c como novo bit mais
significativo do resultado: ( R m ) desl.direita( c R m )
4.1. Deslocar R para direita (carry recebe o bit menos significativo).
4.2. Deslocar r para direita (carry torna-se o novo bit mais significativo).
Se i no for zero, ir para 2. Seno, terminar. Resultado em (R m).
Para a implementao do algoritmo acima, assume-se o seguinte mapeamento de memria
para as variveis e constantes:
multiplicando M: endereo 128 constante 0: endereo 134
multiplicador m: endereo 129 constante 1: endereo 135
resultado R: endereo 130 constante 8: endereo 136
resultado r: endereo 131
contador: endereo 132
multiplicador deslocado: endereo 133
Endereo Instruo Comentrios
0 LDA 136
2 STA 132 Inicializa contador com n (oito no caso)
4 LDA 134
6 STA 130 Inicializa R com zero
8 LDA 129
10 STA 133 Inicializa multiplicador com m
12 LDA 133 Incio do lao: Carrega multiplicador em AC
14 SHR Desloca m; carry recebe o bit menos significativo
15 STA 133 Salva o multiplicador
17 JNC 25 Se no houve carry, vai para o deslocamento
19 LDA 130 Carrega R em AC
21 ADD 128 Soma R + M; resultado parcial no acumulador
23 STA 130 Salva o resultado parcial
25 LDA 130 Carrega resultado parcial (bits mais significativos) em AC
27 ROR Desloca para direita com carry
28 STA 130 Salva o resultado deslocado
30 LDA 131 Carrega resultado parcial (bits menos significativos) em AC
35 LDA 132 Carrega o contador em AC
37 SUB 135 Decrementa de um
39 STA 132 Salva o contador
41 JNZ 12 Se no for zero, executa mais uma vez o lao
43 HLT Fim; resultado em R e m
Esta implementao pode ser otimizada, se os seguintes itens forem observados:
1. Depois do teste do carry (instruo JNC, no endereo 17), os dois ramos a serem
seguidos (endereos 25 e 19) iniciam com a mesma instruo (LDA 130).
2. Como a instruo LDA no altera o carry, ela pode ser deslocada para antes do teste
do carry. Com isto, em vez de duas instrues de LDA, usa-se apenas uma.
3. Como aps a soma sobre R (endereos 19 a 23) segue-se o deslocamento de R
(endereos 25 a 28), pode-se eliminar tambm a instruo STA 130 do endereo 23.
Assim, a implementao fica (mantendo-se o mesmo mapeamento de variveis e constantes):
6-6
0 LDA 136
4 LDA 134
8 LDA 129
19 JNC 23 Se no houve carry (no SHR), vai para o deslocamento
23 ROR Desloca R para direita com carry
39 HLT Fim; resultado em R e r
Uma otimizao em termos de variveis pode ser tentada, observando-se que:
1. Os bits do multiplicador so analisado da direita para esquerda. Isto realizado
trazendo-se os seus bits para os bits menos significativos. Com isto os bits mais
significativos vo sendo liberados, um de cada vez.
2. Os bits menos significativos do resultado parcial vo sendo deslocados para r pela
esquerda, ou seja, os bits so ocupados da esquerda para a direita, um de cada vez.
3. Assim, a medida que os bits menos significativos de m vo sendo analisados, os
bits mais significativos de r vo sendo formados. Assim, pode-se utilizar a mesma
palavra de memria (ou varivel) para r e m.
Com estas observaes, pode-se desenvolver o mtodo final para a multiplicao de dois
nmeros binrios, representados como inteiros positivos (este mtodo vale tambm para
nmeros positivos em complemento de dois). Sejam m, M, R e n definidos como
anteriormente. A varivel i tem a funo de controlar que o lao seja executado n vezes
(de n at zero). A varivel r no mais utilizada; sua funo realizada por m.
O algoritmo deve ser modificado, para se adaptar ao duplo uso de m e r. A varivel m
deslocada no incio do lao, e r deslocada somente no fim. Na implementao abaixo,
optou-se por deslocar m no incio da lao, e somente ajustar o bit mais significativo de r
atravs de uma instruo de OR e uma mscara adequada (constante 128). Com isto, o
algoritmo fica:
1. Incio: i n, R 0
2. Deslocar m para direita (o bit menos significativo vai para o carry). Se o carry
for zero (c=0), ir para 4.
4. Deslocar os 2n bits do resultado para direita, usando o c como novo bit mais
significativo do resultado: ( R m ) desl.direita( c R m )
4.1. Deslocar R para direita (carry recebe o bit menos significativo).
4.2. Testar o carry (que contem o bit menos significativo de R). Se for zero, no
h nada para fazer (o bit mais significativo de m j zero, devido ao passo 2). Se
for um, ligar o bit mais significativo de m.
6-7
Se i no for zero, ir para 2. Seno, terminar. Resultado em (R m).
Para a implementao do algoritmo acima, assume-se o mesmo mapeamento de memria dos
algoritmos anteriores, mas adaptado para este ltimo algoritmo.
multiplicando M: endereo 128 constante 0: endereo 134
multiplicador m: endereo 129 constante 1: endereo 135
resultado R: endereo 130 constante 8: endereo 136
resultado r: endereo 131 constante 128: endereo 137
contador: endereo 132
0 LDA 136
4 LDA 134
8 LDA 129
19 JNC 23 Se no houve carry (no SHR), vai para o deslocamento
23 ROR Desloca R para direita; carry recebe bit menos significativo
26 JNC 34 Se carry zero, bits menos significativos (m) esto OK
30 OR 137 Liga o bit mais significativo do resultado (m)
42 HLT Fim; resultado em R e m
6. 2 Multiplicao binria (nmeros em complemento de dois)
A multiplicao de nmeros com sinal, em complemento de dois, usa o mesmo mtodo
bsico, com trs modificaes (duas no mtodo e uma na realizao da truncagem para n
bits):
1. Repete-se n1 vezes o teste de bit, soma condicional e deslocamento. Na ltima
passagem do lao (na n-sima vez), executa-se uma subtrao condicional no lugar de
uma soma. Isto ocorre porque, em complemento de dois, o bit mais significativo
(sinal) tem peso negativo.
2. No deslocamento para a direita, deve-se agora manter (ou corrigir) o sinal do
resultado intermedirio. Para isto, no se desloca mais com o vai-um da soma (ou
zero). Devem ser observadas as regras:
se no houve soma (ou subtrao) condicional anterior, desloca-se para a direita
duplicando-se o bit de sinal, isto , o bit de sinal deslocado para a direita, e o
novo bit de sinal igual ao anterior.
se houve soma (ou subtrao) anterior, mas no ocorreu estouro, desloca-se para
a direita duplicando-se o bit de sinal.
se houve soma (ou subtrao) anterior, e ocorreu estouro, deslocam-se todos os
bits para a direita (inclusive o bit de sinal), e o novo bit de sinal o inverso do
6-8
sinal anterior. Com isto corrige-se o erro na representao do resultado
introduzido pelo estouro.
3. Na truncagem para n bits, deve-se observar que ela agora possvel em dois casos:
Se os n+1 bits mais significativos forem zeros. Neste caso, tem-se um nmero
positivo em 2n bits que pode ser representado em n bits, sem estouro.
Se os n+1 bits mais significativos forem todos uns. Neste caso, tem-se um
nmero negativo em 2n bits que pode ser representado em n bits, sem
estouro.
Nos demais casos, no possvel truncar o resultado para n bits sem que haja
estouro de representao.
A implementao necessita de um teste de overflow aps a soma, o que j est presente no
Ahmes. Dependendo do sinal do resultado parcial e do overflow, tem-se quatro casos a
tratar:
1. Resultado positivo, sem overflow (N=0, V=0). Neste caso, basta deslocar o resultado
atravs de uma instruo de SHR (que automaticamente coloca um zero no bit mais
significativo, mantendo assim o sinal).
2. Resultado positivo, com overflow (N=0, V=1). Neste caso, desloca-se o resultado
atravs de uma instruo de SHR e depois realiza-se um OR com a mscara binria
10000000 (decimal 128), para tornar o resultado negativo.
3. Resultado negativo, sem overflow (N=1, V=0). Este caso o mesmo do item (2)
acima. Deve-se deslocar o resultado com um SHR e depois ligar o bit de sinal com um
OR com a mscara binria 10000000.
4. Resultado negativo, com overflow (N=1, V=1). Neste caso, como no caso (1) acima,
basta deslocar o resultado atravs de uma instruo de SHR (que coloca um zero no
bit mais significativo, tornando assim o resultado positivo).
Estes quatro casos referem-se simplesmente ao deslocamento dos bits mais significativos do
resultado. Considerando-se a necessidade de identificar o caso e trat-lo adequadamente, e
repetir a anlise separadamente para o ltimo passo (que utiliza subtrao condicional em vez
de soma), a programao deste algoritmo em Ahmes seria bem extensa e complexa. Para o
Ahmes, seria mais simples converter os operandos para nmeros positivos, multiplic-los e
depois ajustar o sinal o resultado de acordo com os sinais dos operandos originais.
Um outro mtodo para multiplicao binria para nmeros em complemento de dois foi
desenvolvido por Booth, e mais rpido que os mtodos descritos acima. Este algoritmo
pode ser encontrado no livro Computer Architecture and Organization, de John P. Hayes, na
seo 3.3.2.
6. 3 Diviso binria (nmeros inteiros positivos)
Em qualquer sistema de numerao, a diviso a operao inversa da multiplicao, ou seja,
seu resultado (quociente) indica quantas vezes podemos subtrair um nmero (divisor) de
outro (dividendo) de forma que ainda reste um nmero positivo ou zero (resto). Na diviso
em decimal, realizam-se exatamente os passos contrrios da multiplicao. Os dgitos do
resultado so calculados da esquerda para direita, e a cada passo determina-se um dgito do
quociente:
7749 63
63 123
144 (7749 6300 = 1449)
126
189 (1449 1260 = 189)
189
0 (189 189 = 0)
6-9
Note-se que, como na multiplicao, o peso de cada casa assumido implicitamente, e os
zeros respectivos no so escritos. Assim, no lugar de 6300 (63 x 1 x 100) anota-se
simplesmente 63 (63 x 1); no lugar de 1260 (63 x 2 x 10) escreve-se 126 (63 x 2). A
diviso apresenta uma dificuldade adicional para sua realizao pelo mtodo esboado acima:
a necessidade de estimar o dgito que deve ser multiplicado pelo divisor para obter a maior
parcela possvel de ser subtrada do dividendo.
Na diviso binria, utiliza-se exatamente o mesmo mtodo, mas o processo de adivinhao
se torna bem mais fcil: s necessrio verificar se o divisor pode ser subtrado dos dgitos
mais significativos do dividendo (bit = 1) ou no (bit = 0).
1 0 1 0 1 1 0 0 0 0 1 0 1 1 0 0 1 1
1 1 0 0 1 1 1 1 0 1 1 0
1 0 0 0 1 1 0
1 1 0 0 1 1
0 1 0 0 1 1 0
1 0 0 1 1 0 0
1 1 0 0 1 1
0 1 1 0 0 1 1
1 1 0 0 1 1
0 0 0 0 0 0
0 0 0 0 0 0
Note-se que, como no sistema decimal, depois de cada subtrao (ou tentativa mal sucedida
de subtrao, se o dgito calculado para o quociente for zero) um novo dgito do dividendo
incorporado anlise, isto , um novo dgito do dividendo baixado para o resultado da
subtrao. E, tambm como no sistema decimal, o nmero de bits do dividendo que
participam da primeira anlise escolhido de tal forma que formem um nmero maior que o
divisor, isto , que a primeira subtrao seja possvel.
Com um dividendo de m bits e um divisor de n bits obtm-se um quociente de mn bits
e um resto de n bits. A diviso em um computador, sendo a operao inversa da
multiplicao, opera com um dividendo de 2n bits, um divisor de n bits e fornece
quociente e resto em n bits. Ao contrrio da multiplicao, entretanto, onde o resultado
sempre representvel sem estouro, na diviso o quociente pode no ser representvel em
n bits. Nestes casos sinaliza-se estouro de representao. Nos casos em que o dividendo
tem somente n bits, ele deve ser inicialmente expandido para 2n bits, incluindo-se n
zeros esquerda do dividendo.
Para diviso de dois nmeros representados como inteiros positivos usa-se o mtodo abaixo,
onde o dividendo D tem 2n bits e o divisor v tem n bits. Note-se que, nesta
representao no existem nmeros negativos. Assim, um teste comparativo deve ser feito
para verificar se a subtrao possvel, ou seja, se o resultado ser um nmero positivo.
Observe-se tambm que sua aplicao restringe-se aos nmeros naturais sem o zero. A
incluso do zero, obrigaria ao teste do valor do divisor, abortando a operao se esta for
uma tentativa de diviso por zero.
1. Incio: formar r com os n+1 bits mais significativos do dividendo D, i n.
2. Se r v, ento subtrair r rv e colocar 1 no bit menos significativo de q
(quociente). Seno, somente colocar 0 no bit menos significativo de q. Obs: neste
passo, usar somente n bits para representar r.
3. Decrementar i (i i1). Se i=0, encerrar. O resto est em r e o quociente em q.
4. Deslocar r para esquerda, mantendo o bit mais significativo (ou seja, representar
r com n+1 bits). Como novo bit menos significativo, utilizar o bit seguinte do
dividendo original (baixar um bit). Deslocar q tambm para a esquerda. Ir para
o passo 2.
Exemplo: sejam D = 101011000010 e v = 110011. Ento tem-se:
6-10
1. r 1010110, i 6
2. r v (1010110 110011). Ento r 1010110 110011 = 100011 e q 1
3. i 5
4. r 1000110, q 1x
2. r v (1000110 110011). Ento r 1000110 110011 = 010011 e q 11
3. i 4
4. r 0100110, q 11x
2. r < v (0100110 < 110011). Ento r 100110 e q 110
3. i 3
4. r 1001100, q 110x
2. r v (1001100 110011). Ento r 1001100 110011 = 011001 e q 1101
3. i 2
4. r 0110011, q 1101x
2. r v (0110011 110011). Ento r 0110011 110011 = 000000 e q 11011
3. i 1
4. r 0000000, q 11011x
2. r < v (0000000 < 110011). Ento r 000000 e q 110110
3. i 0, encerrar. Quociente = 110110 e resto = 0
Para alguns operandos, pode ocorrer que quando for executado o passo 2, na primeira vez, o
resultado da operao r rv seja maior do que v (ou at mesmo igual a v). Nestes
casos, o algoritmo no adequado para realizao da operao (portanto, a diviso no
poder ser realizada por este mtodo: ser necessrio escolher algum outro). Para o uso
adequado deste algoritmo, interessante incluir uma observao no passo 2 de verificao do
resultado da operao r rv. Se aps esta operao obter-se r v, ento deve-se abortar a
operao, pois o quociente exigiria mais de n bits para ser representado.
A situao explicada acima exemplificada com a diviso de 11010100 por 1011. Para este
exemplo, D = 11010100 e v = 1011. Ento tem-se:
1. r 11010, i 4
2. r v (11010 1011). Ento r 11010 1011 = 1111 e q 1
Neste passo, se obtm um valor de r que maior do que o divisor (o que no faz sentido).
O prosseguimento da operao pelo algoritmo faria com que se obtenha uma resposta
incorreta.
Como poderia ser corrigido o algoritmo sem modific-lo demasiadamente? Se, para iniciar a
operao, utilizar-se apenas n bits do dividendo (D), o problema se resolve a nvel do passo
2. Mas agora ser necessria uma interao a mais ( preciso baixar mais um bit de D),
ento i deve ser aumentado em uma unidade. Entretanto esta uma soluo para este caso e
no universal. Experimente mudar o divisor para 0101 e observe o que ocorre. O tipo de
anlise e a viso humana sobre as variveis no so facilmente transportveis para o
computador, o que vai exigir a alterao do algoritmo para implementao na mquina.
Com isto, o algoritmo fica:
1. Incio: Se v for zero, terminar indicando erro de diviso por zero. Seno, calcular D
v. Se carry=1 (borrow=0), ento D v e terminar indicando estouro. Se no,
ento a diviso pode ser realizada.
6-11
i n. Formar r com os n+1 bits mais significativos do dividendo.
2. Se r v, ento subtrair r rv e colocar 1 no bit menos significativo de q
(quociente). Seno, somente colocar 0 no bit menos significativo de q. Obs: neste
passo, usar somente n bits para representar o resultado r.
4. Deslocar r para esquerda, mantendo o bit mais significativo (ou seja, representar
r com n+1 bits). Como novo bit menos significativo, utilizar o bit seguinte do
dividendo original (baixar um bit). Deslocar q tambm para a esquerda. Ir para
o passo 2.
O algoritmo requer que se trabalhe com os n+1 bits mais significativos do dividendo. Isto
pode ser implementado realizando-se um deslocamento para a esquerda do dividendo, de
forma que o carry contenha o bit mais significativo e D contenha os n bits seguintes.
Assim, a comparao entre r (carry e D) e v. Se o carry for um, ento garantidamente
r > v. Se o carry for zero, ento calcula-se Dv. Se o borrow desta operao for zero
(borrow=0), ento rv. Se o borrow for um (borrow=1) ento r<v.
Com estas consideraes, o algoritmo fica:
1. Incio: Se v for zero, terminar indicando erro de diviso por zero. Seno, verificar
se D v. Se sim, ocorrer estouro no quociente. Neste caso, terminar indicando
estouro. Se no, ento a diviso pode ser realizada.
2. Incio: i n, q 0.
3. Deslocar o quociente q para esquerda, preparando-o para receber o novo bit menos
significativo. Deslocar D e d para esquerda (bit mais significativo de D vai para o
carry). Testar D e carry contra v. Se carry =1, ento D > v. Seno, calcular D v.
Se houver borrow, ento D<v. Seno, Dv. No caso de Dv, subtrair D Dv e
colocar 1 no bit menos significativo de q (quociente). Seno, deixar D inalterado e
colocar 0 no bit menos significativo de q (como o deslocamento para esquerda j
inseriu um zero, basta deixar q inalterado).
4. Decrementar i (i i1). Se i=0, encerrar. O resto est em D e o quociente em
q. Seno, ir para o passo 3.
No algoritmo para o AHMES, assume-se que o dividendo esteja nos endereos 128 (D - bits
mais significativos) e 129 (d - bits menos significativos), o divisor v no endereo 130, o
quociente q deve ser colocado em 131 e o resto r em 132. O estado da diviso indicado na
posio 133 (-1 indica estouro na diviso, 0 indica diviso por zero e 1 indica diviso
normal). Para contador ser utilizada a posio 134.
Para as constantes, so utilizadas as seguintes posies: 135 para zero, 136 para um, 137
para menos um (255) e 138 para oito.
Para deixar os valores de D e d inalterados, os seus valores sero copiados para as
posies 139 e 140, respectivamente. Sobre estas posies que sero efetuados os
deslocamentos.
0 LDA 130 Carrega o divisor
2 JZ 77 Se for zero, termina
4 LDA 128 Carrega D em A
6 SUB 130 Calcula D v
8 JNB 81 Se borrow=0, ento D v, e ir ocorrer estouro
10 LDA 128 Tudo bem. Diviso pode ser realizada
12 STA 139 Salva D em endereo temporrio
14 LDA 129 Carrega d
16 STA 140 Salva d em endereo temporrio
18 LDA 138 Obtm a constante 8
6-12
20 STA 134 Inicializa contador com n (8 no caso)
22 LDA 135 Obtm a constante zero
24 STA 131 Inicializa q com zero
26 LDA 131 Carrega q
28 SHL Desloca q para esquerda
29 STA 131 Salva q
33 SHL Desloca d para esquerda (carry recebe bit mais significativo)
34 STA 140 Salva d
36 LDA 139 Carrega D
38 ROL Desloca D para esquerda (com carry)
39 STA 139 Salva D
41 JC 49 Testa o carry (antigo bit mais significativo de D)
43 LDA 139 Carry de D = 0, carrega D
45 SUB 130 Testa se D v
47 JB 61 Testa o borrow; se 1, ento D < v, nada a fazer
49 LDA 139 Borrow=0, ento D > v
51 SUB 130 Atualiza D com Dv
53 STA 139 Atualiza D
57 OR 136 Coloca bit do quociente em 1
59 STA 131 Salva q
61 LDA 134 Carrega contador
63 SUB 136 Decrementa contador de lao
65 STA 134 Salva contador
67 JNZ 26 Se no for zero, termina
69 LDA 139 Obtm o D final
71 STA 132 Salva como resto
73 LDA 136 Sinaliza fim normal
75 JMP 83
77 LDA 135 Sinaliza diviso por zero
79 JMP 83
81 LDA 137 Sinaliza estouro na diviso
83 STA 133 Armazena indicador de estado
85 HLT Fim
O algoritmo acima pode ser otimizado observando-se que:
1. Enquanto os bits de d vo sendo deslocados para a esquerda, os bits de q vo
sendo formados a partir da direita. Assim, de maneira anloga ao caso da
multiplicao, para d e q pode ser utilizada uma s varivel e em consequencia
uma s posio de memria. Assim, os endereos 140 e 131 so reunidos,
eliminado-se o 140.
2. Da varivel D vo sendo realizadas subtraes sucessivas, e no final do algoritmo
o D final o resto. Assim, para D e r pode-se utilizar somente uma varivel.
Assim, dos endereos 139 e 132 elimina-se a necessidade do 139.
Com estas consideraes, o algoritmo fica:
1. Incio: Se v for zero, terminar indicando erro de diviso por zero. Seno, verificar
se D v. Se sim, ocorrer estouro no quociente. Neste caso, terminar indicando
estouro. Se no, ento a diviso pode ser realizada.
2. Incio: i n, q d, r D.
3. Deslocar r e q (ou seja, D e q) para esquerda (bit mais significativo de r vai para o
carry). Testar r e carry contra v. Se carry =1, ento r > v. Seno, calcular r v. Se
houver borrow, ento r<v. Seno, rv. No caso de rv, subtrair r rv e colocar
1 no bit menos significativo de q. Seno, deixar D e q inalterados.
6-13
Seno, ir para o passo 3.
No algoritmo para o AHMES, assume-se que o dividendo esteja nos endereos 128 (D - bits
normal). Para contador ser utilizada a posio 134.
Para as constantes, so utilizadas as seguintes posies: 135 para zero, 136 para um, 137
para menos um (255) e 138 para oito.
Note-se que para D temporrio e r utilizada a mesma posio (132), assim como para
d temporrio e o quociente q utilizada a mesma posio (131). A cpia de D para r
feita no endereo 12 (STA 132), e a cpia de dpara q feita na instruo do endereo 16
(STA 131).
8 JNB 68 Se borrow=0, ento D v, e ir ocorrer estouro
10 LDA 128 Tudo bem. Diviso pode ser realizada
12 STA 132 Salva D como o resto temporrio (r)
16 STA 131 Salva d como quociente temporrio (q)
18 LDA 138 Obtm a constante 8
22 LDA 131 Carrega d (q)
24 SHL Desloca para esquerda (carry recebe bit mais significativo)
25 STA 131 Salva d (q)
27 LDA 132 Carrega D (r)
29 ROL Desloca para esquerda (com carry)
30 STA 132 Salva D (r)
32 JC 40 Testa o carry (antigo bit mais significativo de D(r))
34 LDA 132 Carry de r = 0, carrega r
36 SUB 130 Testa se r v
38 JB 52 Testa o borrow; se 1, ento r < v, nada a fazer
40 LDA 132 Borrow=0, ento r > v
42 SUB 130 Calcula rv
44 STA 132 Atualiza r
46 LDA 131 Carrega d (q)
50 STA 131 Salva d (q)
58 JNZ 22 Se no for zero, termina
62 JMP 70
66 JMP 70
72 HLT Fim
6-14
6. 4 Diviso binria (nmeros em complemento de dois, positivos)
Na representao em complemento de dois, possvel representar nmeros negativos, e
assim o mtodo discutido acima pode ser modificado. No mais necessrio testar para
verificar se a subtrao possvel. Simplesmente realiza-se a subtrao e, se o resultado for
negativo, restaura-se o nmero original somando-se o divisor. Este o mtodo da diviso
com restaurao.
Sejam D o dividendo (com 2n bits) e v o divisor (em n bits). O quociente q ser
ento representado por q
n-1
q
n-2
...q
2
q
1
q
0
em n bits. O algorimo calcula um bit q
i
de cada
vez, da esquerda para a direita (i variando de n-1 at zero). A cada passo i o divisor,
deslocado i bits para a esquerda (representado por 2
i
v), comparado com o resto parcial r
i
(inicialmente, r
n-1
formado pelos bits mais significativos do dividendo). Se 2
i
v for menor
que r
i,
o bit q
i
do quociente colocado em 0. Se 2
i
v for maior (ou igual) que r
i
, o bit q
i
do
quociente colocado em 0, e um novo resto parcial calculado pela operao
r
i-1
r
i
q
i
2
i
v
Nos mtodos normalmente utilizados, mais conveniente deslocar o resto parcial para
esquerda em relao a um divisor fixo. Assim, o divisor permanece sempre v, e o resto
parcial deslocado para a esquerda representado por 2r
i
. Neste caso, a equao acima
equivalente a
r
i-1
2r
i
q
i
v
Quando se realiza uma subtrao tentativa, calcula-se r
i-1
2r
i
v. Esta operao j calcula
o novo resto parcial r
i-1
quando 2r
i
v for positivo, isto , quando q
i
= 1. Se entretanto 2r
i

v for negativo, tem-se q
i
= 0 e o novo resto parcial r
i-1
ser igual ao anterior, ou seja, 2r
i
.
Este resto r
i-1
pode neste caso ser obtido somando-se v de volta ao resultado da subtrao.
Esta a base do mtodo da diviso com restaurao. A cada passagem a operao
r
i-1
2r
i
v
realizada. Quando o resultado negativo, uma adio restauradora necessria:
r
i-1
r
i-1
+ v
r
i-1
(2r
i
v) + v = 2r
i
Se a probabilidade de qi = 1 for 1/2, ento este mtodo requer n subtraes e uma mdia de
n/2 somas. Para o algoritmo abaixo, sejam D os n bits mais significativos do dividendo,
d os n bits menos significativos do dividendo, v o divisor (em n bits). Para d e q
utiliza-se a mesma varivel.
1. Incio: Se v for zero, terminar indicando erro de diviso por zero. Seno, deslocar
(D d) para a esquerda: (D d) desl.esquerda(D d 0). Se D for maior ou igual a v,
ocorrer estouro no quociente. Neste caso, terminar indicando estouro. Seno,
fazer r D, i n e q d.
2. Subtrair r rv. Se r resultante for positivo, colocar 1 no bit menos significativo
de q. Seno, colocar zero no bit menos significativo de q e restaurar r atravs da
soma r r+v.
4. Deslocar (r q) para esquerda: (r q) desl.esquerda(r q 0). Ir para o passo 2.
Na adaptao para o Ahmes, assume-se que o dividendo esteja nos endereos 128 (D - bits
6-15
normal). Para contador ser utilizada a posio 134. Para as constantes, so utilizadas as
seguintes posies: 135 para zero, 136 para um, 137 para menos um (255) e 138 para oito.
Note-se que para d e q e para r e D so utilizadas as mesmas palavras de memria (131 e
132, respectivamente), o que pode ser visto nas instrues dos endereos 7 e 12.
4 LDA 129 Carrega d em A
6 SHL Desloca para esquerda, bit mais significativo vai para carry
7 STA 131 Salva d como q (quociente temporrio)
11 ROL Desloca para esquerda
12 STA 132 Salva D como r (resto temporrio)
16 JP 64 Se D v, ir ocorrer estouro
18 LDA 138 Tudo bem ( D < v ). Diviso pode ser realizada
22 LDA 132 Incio do lao. Obtm r
24 SUB 130 Calcula r v
26 JN 36 Se negativo, nada a fazer (no salva r)
28 STA 132 Se positivo, atualiza r
34 STA 131 Salva q
42 JZ 56 Se for zero, termina normalmente
47 STA 131 Salva q
49 LDA 132 Carrega r
52 STA 132 Salva r
54 JMP 22 Volta para incio do lao
58 JMP 66
62 JMP 66
68 HLT Fim
Note-se que o programa est otimizado no que se refere restaurao do r. A subtrao
realizada (posies 22 e 24) e testada (posio 26). No instante do teste, o resultado rv
est no acumulador, e a varivel r na memria ainda no foi atualizada. Assim, a
restaurao de r realizada simplesmente no salvando o resultado do acumulador, e a
operao r rv realizada salvando-se o acumulador (posio 28).
Uma tcnica um pouco diversa da descrita acima pode ser empregada para eliminar a
necessidade de realizar a soma restauradora. Esta tcnica baseada no fato de uma
restaurao da forma
r
i
r
i
+ v
seguida no prximo passo por uma subtrao da forma:
r
i-1
2r
i
v
6-16
Reunindo-se as duas equaes tem-se
r
i-1
2(r
i
+ v) v = 2r
i
+ 2v v
ou seja,
r
i-1
2r
i
+ v
Assim, quando q
i
= 1, que indica um valor positivo para r
i
, r
i-1
calculado por subtrao do
divisor: r
i-1
2r
i
v. Por outro lado, quando q
i
= 0, r
i-1
calculado por uma simples
soma: r
i-1
2r
i
+ v. Assim, o clculo de cada um dos bits do quociente requer uma soma
ou uma subtrao, mas no ambas. Assim, este mtodo, denominado de diviso sem
restaurao, necessita de n somas e subtraes, enquanto que o mtodo da diviso com
restaurao requer uma mdia de 3n/2 somas e subtraes.
Para o algoritmo abaixo, sejam r os n bits mais significativos do dividendo, d os n
bits menos significativos do dividendo, v o divisor (em n bits). Para controlar se a
prxima operao ser uma soma ou subtrao, usa-se um elemento auxiliar aux,
inicializado para comear-se com uma subtrao.
1. Incio: Se v for zero, terminar indicando erro de diviso por zero. Seno, deslocar
(D d) para a esquerda: (D d) desl.esquerda(D d 0). Se D for maior ou igual a v,
ocorrer estouro no quociente. Neste caso, terminar indicando estouro. Seno,
fazer r D, i n e aux 1.
2. Se aux=1, calcular r rv. Seno, calcular r r+v. Se o r resultante for
positivo, ento colocar 1 no bit menos significativo de q e fazer aux 1. Se o r
resultante for negativo, colocar 0 no bit menos significativo de q e fazer aux 0.
3. Decrementar i (i i1). Se i=0, ir para 5.
4. Deslocar (r d) para esquerda: (r d) desl.esquerda(r d 0). Deslocar q para a
esquerda: q desl.esquerda(q 0). Ir para o passo 2.
5. Se r<0, ento r r+v. Encerrar. O resto est em r e o quociente em q
Como pode ser visto no passo 2, se o dividendo aps uma subtrao ficar negativo, ele no
restaurado, mas sim no prximo passo soma-se o divisor (ao invs de subtrair). Isto
controlado pelo flag aux. Assim, sempre que a operao anterior produzir um dividendo
positivo, a prxima operao uma subtrao; seno, se o dividendo for negativo, a prxima
operao uma soma. Este mtodo necessita, entretanto, corrigir o resto, como indicado no
passo 5.
Na adaptao para o Ahmes, assume-se que o dividendo esteja nos endereos 128 (D - bits
normal). Para contador ser utilizada a posio 134. Para as constantes, so utilizadas as
seguintes posies: 135 para zero, 136 para um, 137 para menos um (255) e 138 para oito.
Para a varivel aux usa-se a posio 139.
4 LDA 129 Carrega d em A
7 STA 131 Salva d como q (quociente temporrio)
12 STA 132 Salva D como r (resto temporrio)
6-17
16 JP 96 Se D v, ir ocorrer estouro
18 LDA 138 Tudo bem ( D < v ). Diviso pode ser realizada
22 LDA 136
24 STA 139 Inicializa aux com 1
26 LDA 139 Incio do lao. Testa aux
28 JZ 38
30 LDA 132 Aux = 1
32 SUB 130 Calcula r v
36 JMP 44
38 LDA 132 Aux = 0
40 ADD 130 Calcula r + v
44 JN 56 Testa o resultado da operao
50 STA 131 Salva q
52 LDA 136 Faz aux=1 (prxima operao uma subtrao)
54 JMP 58
56 LDA 135 Faz aux=0 (prxima operao uma soma)
58 STA 139 Atualiza varivel aux
66 JZ 80 Se for zero, termina normalmente
71 STA 131 Salva q
73 LDA 132 Carrega r
76 STA 132 Salva r
78 JMP 26 Volta para incio da lao
80 LDA 132 Fim do lao. Testa valor do resto
82 JP 88 Se for positivo, est correto
84 ADD 130 Se negativo, soma divisor ao resto
86 STA 132 Salva resto corrigido
90 JMP 98
94 JMP 98
100 HLT Fim
No lugar de corrigir o resto, alguns autores preferem realizar o lao n1 vezes (e no n
vezes, como acima), e na ltima passagem forar o bit menos significativo do quociente para
1. O resultado final sempre ser algebricamente correto, no sentido que quociente vezes
divisor mais resto igual ao dividendo, mas pode produzir anomalias como 21 5 = 5 e
resta 4, ou ento at mesmo 20 5 = 5 e resta 5 (!). Mas 15 5 = 3 e resta zero, assim
como 19 5 = 3 e resta 4. Como o quociente sempre ser impar (devido ao bit menos
significativo ser forado para um), esta anomalia ocorre sempre que o quociente correto seria
um nmero par. A correo, entretanto, fcil: sempre que o resto for negativo, basta
subtrair um do quociente e somar o divisor ao resto.
Exemplo de uso do mtodo: seja a diviso de 000111000111 por 010001, ambos
interpretados como nmeros em complemento de dois (note-se que ambos so positivos):
6-18
1. i 0, aux 1, r 000111, d 000111. Deslocando (r d) para esquerda,
resulta em r 001110, d 001110. Como r<v e v0, a diviso pode prosseguir.
2. r 001110 010001 = 001110+ 101111 = 111101, q 0, aux 0
3. i 1; i < 6; ir para 4
4. r 111010, d 011100, q 0x
2. r 111010 + 010001 = 001011, q 01, aux 1
3. i 2; i < 6; ir para 4
4. r 010110, d 111000, q 01x
2. r 010110 010001= 010110+ 101111 = 000101, q 011, aux 1
3. i 3; i < 6; ir para 4
4. r 001011, d 110000, q 011x
2. r 001011 010001= 001011+ 101111 = 111010, q 0110, aux 0
3. i 4; i < 6; ir para 4
4. r 110101, d 100000
2. r 110101 + 010001= 000110, q 01101, aux 1
3. i 5; i < 6; ir para 4
4. r 001101, d 000000, q 01101x
2. r 001101 010001= 001101+ 101111 = 111100, q 011010, aux 0
3. i 6; i 6; ir para 5
5. r 111100 + 010001 = 001101. Quociente = 011010 e resto = 001101. Ou seja,
dividindo-se 455 por 17 obtm-se 26 e resta 13.
Seja agora a diviso de 001011000010 por 010011, ambos em complemento de dois. Neste
caso, o passo um indica que r > v, ou seja, 010110 > 010011. Neste caso, a diviso no
possvel, pois o dividendo no representvel em seis bits (estouro de representao). Em
decimal, a diviso desejada seria de 706 por 19, o que resultaria em um quociente de 37, que
no representvel em complemento de dois em seis bits.
Na diviso de 001000010010 por 010011, o resultado obtido ser 011011, com resto de
010001. Neste caso, o resto j produzido correto, sem necessidade de correo no
passo 5.
6. 5 Diviso binria (nmeros em complemento de doi s, positivos ou
negativos)
O mtodo da diviso sem restaurao pode ser generalizado para nmeros inteiros positivos e
negativos. Para a diviso ser possvel sem estouro, a comparao inicial requer que o valor
absoluto de r seja menor que o valor absoluto de v. Se o sinais de dividendo e divisor
forem iguais, inicia-se com uma subtrao; seno inicia-se com uma soma. Aps cada
subtrao (ou soma), comparam-se os sinais do divisor e do resultado. Se forem iguais, um
bit 1 colocado no quociente, e a prxima operao uma subtrao. Se forem diferentes,
um bit 0 adicionado ao quociente, e a prxima operao uma soma. O bit final do
quociente forado para 1, independente do valor da anlise dos sinais.
O resultado est algebricamente correto, no sentido do quociente ser igual ao divisor vezes o
quociente mais o resto. Entretanto, pode ocorrer que dividendo e resto tenha sinais
diferentes, assim como que o resto seja igual ao divisor. Para corrigir-se quociente e resto,
de forma que o resto seja sempre menor que o divisor e seu sinal igual ao do dividendo, o
seguinte procedimento necessrio:
6-19
se o resto for zero, o resultado est correto.
se o resto for diferente de zero, comparam-se os sinais do dividendo e do resto. Se
forem diferentes, ento corrige-se o resultado:
se dividendo e divisor tiverem os mesmos sinais, subtrai-se um do quociente o
soma-se o divisor ao resto para obter-se o resto real.
se dividendo e divisor tiverem sinais diferentes, soma-se um ao quociente e
subtrai-se o divisor do resto para a obteno do resto real.
se o resto for diferente de zero, dividendo e resto forem ambos negativos, e o valor
absoluto do resto for igual ao valor absoluto do divisor, ento o resto zero e o
quociente deve ser corrigido. Se o divisor for negativo, soma-se um ao quociente, caso
contrrio subtrai-se um.
6. 6 Exerccios resolvidos
Ateno: para os exerccios a seguir todos os nmeros sugeridos so inteiros positivos.
1. Multiplicar 1011 por 1101.
Empregando-se o algoritmo explicado na seo 4.1, tem-se o desenvolvimento apresentado a
seguir. As variveis so: M = 1011 e m = 1101.
1. i 0, R 0, r 0, M 1011, m 1101.
2. m
0
= 1, continuar em 3.
3. R 0 + 1011 = 1011; c = 0
4. (Rr) desl.dir(010110000) = (01011000)
5. i 1; i < 4, ir para 2.
2. m
1
= 0, c = 0, continuar em 4.
4. (Rr) desl.dir(0010110000) = (00101100)
5. i 2; i < 4, ir para 2.
2. m
2
3. R 0010 + 1011 = 1101; c = 0
4. (Rr) desl.dir(011011100) = (01101110)
5. i 3; i < 4, ir para 2.
2. m
3
3. R 0110 + 1011 = 0001; c = 1
4. (Rr) desl.dir(100011110) = (10001111)
5. i 4; fim. Resultado = 10001111.
2. Multiplicar 11010 por 1111.
1. i 0, R 0, r 0, M 11010, m 01111.
2. m
0
3. R 0 + 11010 = 11010; c = 0
4. (Rr) desl.dir(01101000000) = (0110100000)
5. i 1; i < 5, ir para 2.
2. m
1
3. R 01101 + 11010 = 00111; c = 1
4. (Rr) desl.dir(10011100000) = (1001110000)
5. i 2; i < 5, ir para 2.
2. m
2
3. R 10011 + 11010 = 01101; c = 1
6-20
4. (Rr) desl.dir(10110110000) = (1011011000)
5. i 3; i < 5, ir para 2.
2. m
3
3. R 10110 + 11010 = 10000; c = 1
4. (Rr) desl.dir(11000011000) = (1100001100)
5. i 4; i < 5, ir para 2.
2. m
4
= 0, c = 0, continuar em 4.
4. (Rr) desl.dir(01100001100) = (0110000110)
5. i 5; fim. Resultado = 110000110.
3. Sugestes de valores para outros exerccios:
a) Multiplicar 11001 por 10111.
b) Multiplicar 1101 por 101.
c) Multiplicar 110000 por 110100.
d) Multiplicar 101 por 1000.
e) Multiplicar 110 por 111.
Respostas:
a) Produto = 1000111111
b) Produto = 1000001
c) Produto = 100111000000
d) Produto = 101000
e) Produto = 101010
4. Dividir 10010100 por 1011:
Tem-se que D = 10010100 e v = 1011. Ento inicia-se a aplicao do algoritmo (seo 4.3):
1. r 10010, i 4
2. r v (10010 1011). Ento r 10010 1011 = 0111 e q 1
3. i 3
4. r 01111, q 1x
2. r v (01111 1011). Ento r 01111 1011 = 0100 e q 11
3. i 2
4. r 01000, q 11x
2. r < v (01000 < 1011). Ento q 110
3. i 1
4. r 10000, q 110x
2. r v (10000 1011). Ento r 10000 1011 = 0101 e q 1101
5. Dividir 1100101001 por 1111:
Tem-se que D = 1100101001 e v = 11111. Ento:
1. r 110010, i 5
2. r v (110010 11111). Ento r 110010 11111 = 10011 e q 1
3. i 4
4. r 100111, q 1x
2. r v (100111 11111). Ento r 100111 11111 = 1000 e q 11
3. i 3
4. r 010000, q 11x
6-21
2. r < v (010000 < 11111). Ento q 110
3. i 2
4. r 100000, q 110x
2. r v (100000 11111). Ento r 100000 11111 = 00001 e q 1101
3. i 1
4. r 000011, q 1101x
2. r < v (000011 < 11111). Ento q 11010
6. Sugestes de valores para outros exerccios:
a) Dividir 1000111111 por 11001.
b) Dividir 1000101 por 1101.
c) Dividir 100111011000 por 110000.
d) Dividir 101010 por 101.
e) Dividir 101010 por 110.
Respostas:
a) Quociente = 10111 e resto = 0
b) Quociente = 101 e resto = 100
Obs.: Se voc obteve resposta incorreta para este exerccio, verifique quantos dgitos
usou para representar D (D deve ter 2n bits)
c) Quociente = 110100 e resto = 11000
d) A aplicao do algoritmo da seo 6.3 no possvel, uma vez que obtm-se resto
igual ao divisor no passo 2. Usando a diviso convencional obtm-se: quociente =
1000 e resto = 10 (ocorre estouro de representao no quociente).
e) Quociente = 111 e resto = 0

Cap 06

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cap 06

Transféré par

Droits d'auteur :

Formats disponibles

6-1

Vous aimerez peut-être aussi