Se você tivesse que implementar a soma de dois números inteiros representados usando 8 bits em excesso de k com k=127, quais seriam os passos para realizar essa operaçīo?

Passo 1

Primeiro vamos entender direitinho o que significa “8 bits em excesso de k com k=127”.
  • Um valor armazenado de 8 bits, que vou chamar de X, é um número inteiro sem sinal entre 0 e 255.
  • O inteiro real que esse X representa é \;x = X - k\; com k=127. Ou seja, o intervalo representável é
x \in \{-127,\,-126,\dots,0,\dots,127,128\},
porque X varia de 0 a 255 e x=X-127 varia de -127 a 128.
O que o exercício pede: dado dois valores armazenados de 8 bits em excesso-127 (vou chamar A e B), apresentar os passos para implementar a soma dos inteiros que eles representam e produzir o resultado também em excesso-127 (se couber).

Passo 2

Vou escrever as relações matemáticas que ligam as quantidades:
  • Se A e B são os bytes armazenados, os inteiros reais são
a = A - k,\qquad b = B - k.
  • A soma real é
s = a + b = (A - k) + (B - k) = (A + B) - 2k.
  • Para devolver o resultado no mesmo formato em excesso-127, precisamos produzir o byte
S = s + k = \bigl((A+B)-2k\bigr) + k = (A + B) - k.
Essa fórmula é a grande sacada: em vez de decodificar, somar e recodificar, dá para somar diretamente os bytes A+B e depois subtrair o viés k.

Passo 3

Implementação prática passo a passo (visão geral, adequada tanto para software quanto hardware):
  1. Trate A e B como inteiros sem sinal de 8 bits ( 0 255). Use um registrador temporário de pelo menos 9 bits para evitar perder carry.
  2. Calcule o somatório temporário de maior precisão:
\text{temp} = A + B,
onde \text{temp} pode variar de 0 a 510 (ou seja, cabe em 9 bits).
3. Subtraia o viés k:
S = \text{temp} - k = \text{temp} - 127.
Implemente a subtração com um somador (fazendo \text{temp} + (\text{two's complement of }127)) ou com um subtrator direto; mantenha o resultado em pelo menos 9 bits (pois S pode variar de -127 a 383).
4. Detecte overflow/underflow de representação: o valor final armazenável em 8 bits deve satisfazer 0 \le S \le 255. Se S<0 ou S>255 então a soma dos inteiros reais não cabe no formato de 8 bits em excesso-127 (ou seja, ocorreu overflow aritmético) e deve-se sinalizar erro/overflow ou aplicar política desejada (truncar, saturar, provocar exceção, etc.).
5. Se não houve overflow, o byte de saída é simplesmente os 8 bits menos significativos de S (ou, equivalentemente, S representado em 8 bits): esse é o resultado em excesso-127. O inteiro real resultante é s = S - k.

Passo 4

Como detectar overflow de forma simples em implementações concretas:
  • Em software: calcule \text{temp} = A+B com tipo inteiro maior (por exemplo 16 bits), calcule S=\text{temp}-127. Verifique se 0 \le S \le 255. Se sim, retorne \text{byte}(S). Se não, trate overflow.
  • Em hardware com somadores: faça um somador de 8 bits com carry-out para obter \text{temp} de 9 bits; depois subtraia 127 (operando em 9 bits). Assim o bit mais significativo do resultado de 9 bits indica se S>255 (se esse bit for 1 então S\ge256). Para detectar S<0, verifique se houve borrow na subtração (ou compare \text{temp}<127). Em resumo:
    • Condição S<0 se \text{temp} < 127.
    • Condição S>255 se \text{temp} - 127 > 255 equival. \text{temp} > 382 (mas mais simples é testar bit 8 do resultado em 9 bits).

Passo 5

Exemplos concretos — para fixar:
  • Exemplo sem overflow: some a=5 e b=10. Em excesso-127: A = 5 + 127 = 132,\qquad B = 10 + 127 = 137.
\text{temp}=A+B=269,\qquad S=\text{temp}-127=142.
S=142 cabe em 8 bits; o inteiro resultante é 142-127=15. Tudo certo.
  • Exemplo com overflow: some a=128 e b=1. Esses a e b estão nos limites (note que 128 é o máximo representável): A=128+127=255,\qquad B=1+127=128.
\text{temp}=383,\qquad S=\text{temp}-127=256.
Aqui S=256 não cabe em 8 bits ( >255) — overflow ocorreu (o resultado real seria 129, que não é representável no intervalo -127..128).

Passo 6

Observações finais e alternativas:
  • Alternativa trivial e segura: decodificar para inteiros com sinal (por exemplo, a=A-127 e b=B-127), somar s=a+b, verificar se s está em [-127,128] e então codificar S=s+127. Essa via é mais direta em software e evita pensar em truques com bias, mas é um passo a mais de subtração/adição.
  • Em hardware de alto desempenho costuma-se usar a fórmula direta S=(A+B)-k para economizar etapas. Só cuidado com largura dos registradores e sinais de overflow.

Resposta

  1. Receber A,B (bytes em excesso-127).
  2. Calcular \text{temp}=A+B em pelo menos 9 bits.
  3. Calcular S=\text{temp}-127 (manter 9 bits).
  4. Se S<0 ou S>255 => overflow (resultado não representável).
  5. Se não houve overflow => saída é o byte de 8 bits S (que representa o inteiro s=S-127).

Exercícios relacionados