Aritmética computacional

Um somador binário realiza a mesma pequena tarefa em cada posição de bit. Ele combina os dois bits dos operandos com um vai-um da posição à direita. O significado do padrão de bits completo vem depois.

Acompanhe o vai-um

Um meio somador tem duas entradas: sua soma é o XOR delas e seu vai-um é o AND delas. Um somador completo também aceita um vai-um de entrada:

Aqui a multiplicação significa AND e a adição significa OR. A soma é 1 para um número ímpar de entradas iguais a 1; o vai-um é 1 para pelo menos duas. Encadear somadores completos forma um somador com propagação de vai-um. Apenas o bit 0 recebe o vai-um inicial; cada bit posterior recebe o vai-um produzido pelo vizinho.

Para 23 + 45, escreva 0001 0111 + 0010 1101. No bit 0, 1 + 1 produz soma 0 e vai-um 1. No bit 1, 1 + 0 + 1 novamente produz 0 e vai-um 1. No bit 2, três entradas iguais a 1 produzem soma 1 e vai-um 1. Continuando para a esquerda, obtemos 0100 0100, ou 68, sem vai-um final.

Um resultado de n bits mantém apenas os n bits menos significativos, portanto o circuito calcula a soma módulo $2^n$. Em 8 bits, 1111 1100 + 0000 0101 produz 0000 0001 e vai-um de saída 1. Interpretado com sinal, isso é −4 + 5 = 1. Interpretado sem sinal, é 252 + 5 = 257, cujos oito bits menos significativos representam 1. O circuito não mudou; o intervalo permitido mudou.

Transforme subtração em adição

O complemento de dois fornece a identidade

Uma linha de controle de subtração aplica XOR a cada bit do segundo operando com 1, invertendo-o, e define o vai-um de entrada inicial como 1. Para adição, essa linha é 0, portanto o segundo operando passa inalterado e o vai-um inicial é 0.

Para calcular 23 − 45, inverta 0010 1101 para 1101 0010. Some 0001 0111 + 1101 0010 + 1 para obter 1110 1010, com vai-um de saída 0. Seu valor com sinal é −22. Deixar o vai-um inicial em 0 produziria −23: a inversão sozinha fornece um a menos que o valor negativo necessário.

Para subtração sem sinal, vai-um de saída 1 significa nenhum empréstimo; vai-um de saída 0 significa que foi necessário um empréstimo. Assim, o vai-um de saída 0 em 23 − 45 indica um resultado sem sinal abaixo de zero. O Arm registra esse vai-um que indica ausência de empréstimo; o x86 registra seu inverso como indicador de empréstimo.

Iguale as larguras antes de operar

No RISC-V, lb estende um byte com sinal, lbu o estende com zeros e addi estende seu imediato de 12 bits com sinal. Escolha a extensão conforme o significado do operando antes de enviar os bits ao somador.

O valor com sinal mais negativo não tem um correspondente positivo na mesma largura. Negar 1000 0000 de 8 bits o inverte para 0111 1111 e soma 1, retornando 1000 0000. O +128 desejado precisa de um formato com sinal mais largo.

Estouro significa que o resultado exato está fora do intervalo do destino. Valores sem sinal de n bits vão de 0 a $2^n-1$; valores com sinal em complemento de dois vão de $-2^{n-1}$ a $2^{n-1}-1$. Oito bits comportam de 0 a 255 sem sinal ou de −128 a 127 com sinal. O mesmo resultado armazenado pode ser válido em uma interpretação e representar estouro na outra.

Teste o sinal correto

Para adição ou subtração com sinal, o hardware pode usar

em que os dois sinais de vai-um entram e saem da posição de sinal. O vai-um de saída sozinho responde à questão sem sinal.

Some 107 e 54 em 8 bits: 0110 1011 + 0011 0110 produz 1010 0001. Um vai-um entra no bit 7, mas nenhum sai, portanto o estouro é 1. O valor sem sinal 161 cabe; a interpretação com sinal −95 não é igual à soma real 161. Por outro lado, −4 + 5 produz vai-um 1, mas estouro com sinal 0. Somar 1000 0000 a si mesmo produz vai-um 1 e estouro 1, portanto ambas as interpretações falham.

Somar sinais opostos não pode causar estouro: a soma exata está entre os operandos. A subtração precisa de sua própria regra de sinal porque subtrair um número negativo aumenta o primeiro operando. Por exemplo, 100 − (−40) é grande demais para 8 bits com sinal, embora ambos os valores de entrada caibam.

Saiba o que a instrução faz

No x86, add define indicadores de vai-um e de estouro. No Arm, operações que atualizam indicadores, como ADDS, os definem; o ADD comum preserva os indicadores existentes. No MIPS, add e addi geram armadilha em caso de estouro com sinal, enquanto addu e addiu não geram. A adição de inteiros no RISC-V grava os bits menos significativos e não tem indicadores de estouro nem armadilha de estouro aritmético.

Após add t0, t1, t2, uma verificação sem sinal no RISC-V é:

bltu t0, t1, overflow

Uma soma sem sinal que deu a volta é menor que um operando original. Valores com sinal precisam de outra verificação:

slti t3, t2, 0
slt  t4, t0, t1
bne  t3, t4, overflow

A primeira instrução registra se o segundo operando é negativo. A segunda registra se o resultado é menor que o primeiro operando. Sem estouro, esses testes concordam: somar um negativo reduz o valor, enquanto somar um não negativo não pode reduzi-lo. Uma diferença detecta estouro. Para um imediato positivo conhecido, basta um desvio com sinal que teste se a soma diminuiu.

Separe o hardware das regras da linguagem

Em C e C++, a aritmética sem sinal dá a volta módulo $2^n$; o estouro com sinal é comportamento indefinido. Em Java, int e long dão a volta, enquanto Math.addExact informa o estouro com uma exceção. Os inteiros do Python crescem conforme necessário. Portanto, o fato de o hardware dar a volta não determina o que um programa em C pode fazer.

Adições e subtrações que dão a volta preservam um resultado final que cabe na representação: na aritmética modular de 8 bits, (100 + 50) − 60 dá a volta primeiro para −106 e depois para 90. Esse raciocínio se aplica à aritmética que dá a volta, não a expressões com sinal em C que estouram.

A saturação é uma política diferente. Em 8 bits sem sinal, 200 + 100 satura em 255 em vez de dar a volta para 44. Isso é útil para intensidades de pixels e outros sinais limitados, em que transformar um grande resultado positivo em um valor pequeno ao dar a volta seria enganoso.

Uma unidade lógica e aritmética, ou ULA, recebe operandos e entradas de controle e produz um resultado e saídas de estado. Ela é combinacional: suas saídas dependem das entradas atuais. Registradores guardam operandos e recebem resultados; a própria ULA não armazena nada.

Construa um bit e depois repita

Uma fatia de 1 bit calcula AND, OR e uma soma de somador completo em paralelo. Um multiplexador seleciona qual resultado candidato chega ao bit de resultado. Em uma ULA de n bits, todas as fatias compartilham os controles de operação, enquanto o vai-um de saída de cada somador alimenta o vai-um de entrada da fatia seguinte. Operações lógicas funcionam independentemente em cada posição; a adição depende da cadeia de vai-um.

Um controle Bnegate inverte o segundo operando e define o vai-um de entrada do bit 0. Selecionar o somador então calcula a subtração. As fatias mais significativas recebem seu vai-um da fatia anterior, não diretamente de Bnegate. Ativar todas as entradas de vai-um inseriria valores um extras no cálculo.

Um controle Ainvert também pode inverter o primeiro operando. Selecionar AND com ambos os operandos invertidos produz NOR pela lei de De Morgan:

Selecionar OR com ambos invertidos produz NAND. Nessas equações lógicas, o sinal de mais denota OR.

Leia uma palavra de controle

Uma ULA clássica de livro didático usa os campos Ainvert, Bnegate e um seletor Operation de dois bits:

Essas são as codificações desse projeto específico. São controles internos, não codificações de instruções RISC-V.

Para as entradas 0101 e 0011, o controle 0110 inverte a segunda entrada para 1100 e fornece vai-um inicial 1. O somador produz 0010, com vai-um de saída 1: 5 − 3 = 2, sem empréstimo sem sinal. Selecionar AND para as entradas originais produziria 0001. Os valores de entrada podem permanecer fixos enquanto uma mudança de controle seleciona outro caminho de resultado.

A fatia mais significativa também fornece informações de estouro e comparação. Uma redução de todos os bits de resultado fornece Zero. Essas saídas de estado permitem que o controle do processador ao redor teste o resultado aritmético sem armazenar um segundo resultado de largura completa.

Acrescente deslocamento ao lado do somador

Uma ULA completa para inteiros básicos do RISC-V também precisa de XOR, comparação sem sinal e deslocamentos. Um deslocador de barril usa uma sequência de níveis de multiplexadores. Cada nível deixa sua entrada passar ou a desloca por uma potência de dois. Um deslocador de 32 bits tem níveis para 1, 2, 4, 8 e 16 posições, portanto realiza qualquer deslocamento de 0 a 31 em cinco níveis.

Para deslocar 13 posições, selecione os níveis de 8, 4 e 1. Os deslocamentos selecionados se combinam em um resultado. Um deslocamento lógico à direita insere zeros. Um deslocamento aritmético à direita replica o bit de sinal, preservando o sinal de um valor negativo. Assim, 1111 0000 deslocado duas posições à direita produz 0011 1100 logicamente e 1111 1100 aritmeticamente.

Comparações frequentemente reutilizam a subtração. A igualdade pergunta se a diferença é zero. A ordenação pergunta se a diferença matemática é negativa, o que exige cuidado extra quando uma subtração de largura fixa estoura.

Detecte igualdade em todos os bits

A saída Zero é o NOR de todos os bits do resultado:

Um único bit de resultado diferente de zero torna Zero falso. Subtrair dois padrões de bits iguais produz zero; dois padrões distintos de n bits não podem diferir por um múltiplo diferente de zero de $2^n$, portanto uma subtração que dá a volta não cria uma falsa igualdade. Um circuito alternativo de igualdade aplica XOR aos bits correspondentes dos operandos e testa se todos os resultados XOR são zero.

Corrija o sinal para menor que com sinal

A instrução slt do RISC-V grava o inteiro 1 na largura completa se o primeiro operando com sinal for menor, ou 0 caso contrário. Em uma ULA segmentada em fatias, a fatia mais significativa calcula um sinal Set e o envia de volta à entrada Less do bit 0. Todos os bits de resultado mais significativos são forçados a zero.

O sinal Set correto é

Quando não há estouro, o sinal da diferença funciona diretamente. Quando há estouro, esse sinal é invertido em relação à diferença real, portanto o XOR com 1 o corrige.

Compare 7 com −8 em quatro bits. A subtração 0111 + 0111 + 1 produz 1111. Seu sinal sugere uma diferença negativa, mas a diferença exata é 15, fora do intervalo de −8 a 7. O estouro é 1, portanto o sinal Less corrigido é 1 XOR 1 = 0. O resultado de slt é 0000, indicando corretamente que 7 não é menor que −8.

Use o empréstimo para menor que sem sinal

A comparação sem sinal usa outro sinal:

para uma subtração realizada com a segunda entrada invertida e vai-um inicial 1. Vai-um de saída 0 significa que foi necessário um empréstimo, portanto o primeiro operando sem sinal é menor.

Essa distinção aparece em slt em comparação com sltu, e nos desvios blt em comparação com bltu e bge em comparação com bgeu. Nem o sinal do resultado sozinho nem um “indicador de negativo” genérico responde às duas perguntas.

Aplique a comparação em software

Uma verificação de limites sem sinal pode rejeitar índices negativos e também índices iguais ou superiores ao comprimento do vetor:

bgeu x10, x11, IndexOutOfBounds

Aqui x10 contém o índice com sinal e x11 contém um comprimento não negativo que cabe no intervalo com sinal. Um índice negativo, reinterpretado como sem sinal, é pelo menos $2^{n-1}$ e, portanto, excede todo comprimento desse tipo. A condição sobre o comprimento importa: ela torna suficiente uma comparação sem sinal.

Conversões da linguagem também podem mudar o significado de uma comparação. Com um unsigned int de 32 bits em C, -1 < 0u é falso porque −1 é convertido em 4.294.967.295 antes da comparação. Acompanhe a conversão antes de raciocinar a partir do sinal de menos escrito.

O vai-um de um somador com propagação precisa atravessar cada bit em sequência. A antecipação de vai-um (carry lookahead) substitui essa espera sequencial por uma lógica que prevê os sinais de vai-um a partir dos bits dos operandos e do vai-um inicial.

Descreva o comportamento de cada bit em relação ao vai-um

Defina geração e propagação como

Essas são expressões booleanas: multiplicação é AND e adição é OR. Geração é 1 quando o bit cria um vai-um independentemente do vai-um de entrada. Propagação é 1 quando um vai-um de entrada pode passar adiante. A recorrência é

Um bit com ambas as entradas iguais a 1 gera um vai-um; um bit com uma entrada igual a 1 passa um vai-um; um bit com ambas as entradas iguais a 0 o interrompe. Com essa definição por OR, um bit que gera vai-um também tem propagação igual a 1, o que não altera a fórmula do vai-um.

Expanda a dependência

Substitua a expressão de cada vai-um anterior:

Cada expressão agora depende de sinais derivados dos operandos e do vai-um inicial, não de uma cadeia sequencial de saídas intermediárias de vai-um. Quando os sinais de vai-um estão disponíveis, cada bit de soma continua sendo o XOR de suas duas entradas e do vai-um de entrada.

Para 1011 + 0110 com vai-um inicial 0, a geração a partir do bit 0 é 0, 1, 0, 0 e a propagação é 1, 1, 1, 1. Assim, os sinais de vai-um de entrada dos bits 1 a 4 são 0, 1, 1, 1. Os quatro bits de resultado são 0001 com vai-um de saída 1, representando 11 + 6 = 17.

Construa grupos em vez de portas gigantes

Um bloco de quatro bits tem os sinais de grupo

Seu vai-um de saída é $G+P{c}_0$. Um segundo nível de antecipação combina esses sinais de bloco usando a mesma regra. Quatro blocos de quatro bits e uma unidade de antecipação de grupo formam um somador de 16 bits. Agrupamentos adicionais permitem projetos mais largos; somadores de prefixo paralelo, como o Kogge–Stone, organizam essas relações em uma rede rápida.

Em um modelo simples de atraso de portas, a propagação de vai-um custa cerca de dois atrasos de porta por bit, ou 32 para 16 bits. Um projeto de antecipação em dois níveis pode fornecer o último vai-um em cerca de cinco: um para os sinais de bit, dois para os sinais de grupo e dois para o vai-um de grupo. Essa estimativa conta níveis lógicos e pressupõe as portas necessárias; o atraso real também depende do tamanho das portas e das conexões. O agrupamento troca mais hardware por um caminho de vai-um que cresce aproximadamente de forma logarítmica com a largura.

Um somador com seleção de vai-um usa área de outra forma: calcula um bloco mais significativo duas vezes, uma para vai-um de entrada 0 e outra para vai-um de entrada 1. Um multiplexador seleciona o resultado correto quando chega o vai-um do bloco menos significativo.

Alguns somadores definem propagação com XOR em vez de OR. Isso também fornece sinais de vai-um corretos e permite obter a soma $s_i=p_i\oplus c_i$. Mantenha a definição escolhida consistente ao derivar a lógica de grupo.

Cada bit do multiplicador binário escolhe uma cópia deslocada do multiplicando ou zero. Somar esses produtos parciais fornece o resultado. Um operando de n bits multiplicado por um operando de m bits pode exigir n + m bits, portanto dois operandos de 32 bits precisam de um produto completo de 64 bits.

Acompanhe deslocamentos e somas

Para operandos sem sinal de n bits, inicialize um produto de 2n bits com zero. Repita n vezes: teste o bit menos significativo do multiplicador, some o multiplicando atual se esse bit for 1, desloque o multiplicando à esquerda e desloque o multiplicador à direita. O registrador do multiplicando precisa ser largo o suficiente para manter suas cópias deslocadas.

Para 6 × 5 em quatro bits, o multiplicador é 0101:

O produto final é 30. O bit testado e a direção do deslocamento funcionam juntos: testar o bit mais significativo enquanto o multiplicador é deslocado à direita associaria os bits aos pesos errados. Esse projeto sequencial leva n etapas, incluindo etapas cujo bit do multiplicador é zero.

Compartilhe espaço no registrador

O primeiro projeto usa um registrador de multiplicando e um somador de 2n bits. Um projeto aperfeiçoado mantém o multiplicando fixo em n bits, coloca o multiplicador na metade menos significativa de um registrador de produto de 2n bits e inicializa a metade mais significativa com zero.

Quando o bit menos significativo é 1, some o multiplicando à metade mais significativa. Mantenha o vai-um de saída do somador em um bit extra e depois desloque esse vai-um e as duas metades do produto juntos à direita. Os bits do multiplicador saem pela direita enquanto bits do produto ocupam o espaço liberado. Descartar o vai-um prejudica produtos grandes: com operandos de quatro bits, 15 × 15 se tornaria incorretamente 1 em vez de 225. Com uma etapa por clock, a implementação simples de 32 bits leva cerca de 32 ciclos.

Considere a largura do produto

Um produto sem sinal cabe em n bits exatamente quando os n bits mais significativos do produto completo são zero. Para 6 × 5, o resultado completo é 0001 1110; armazenar apenas 1110 produz 14. A multiplicação em si estava correta, mas o destino estreito descartou parte dela.

Um deslocamento de k bits à esquerda multiplica por $2^k$ quando o resultado cabe na representação. A multiplicação por 8 torna-se um deslocamento de três posições; a multiplicação por 10 pode usar duas cópias deslocadas:

(x << 3) + (x << 1)

A operação aritmética é $8x+2x=10x$. As regras de largura e da linguagem de programação ainda se aplicam aos deslocamentos e à adição; essa reescrita não cria mais bits de resultado.

Interprete as metades do resultado no RISC-V

mul retorna os XLEN bits menos significativos, em que XLEN é a largura do registrador de inteiros. mulhu retorna a metade mais significativa para operandos sem sinal. As instruções para a metade mais significativa com sinal são mulh para dois operandos com sinal e mulhsu para um primeiro operando com sinal e um segundo sem sinal.

O software que precisa do produto completo pode emitir a instrução apropriada para a metade mais significativa seguida de mul com os mesmos operandos. Uma implementação pode fundir o par. O resultado menos significativo sozinho não pode estabelecer se um produto sem sinal cabe na representação; a metade mais significativa fornece essa evidência.

A multiplicação com sinal deve tratar os sinais dos operandos sem perder o valor mais negativo. O hardware mais rápido também precisa reduzir muitos produtos parciais sem esperar uma adição completa com propagação de vai-um a cada vez.

Multiplique módulos com segurança

Uma abordagem registra os sinais, forma módulos sem sinal de n bits, multiplica-os em 2n bits e nega o produto completo se exatamente um operando for negativo. Para −8 em quatro bits, os bits de módulo 1000 representam 8 sem sinal. Eles não podem ser interpretados como um valor positivo com sinal de quatro bits.

Os n bits menos significativos do produto são idênticos nas interpretações com e sem sinal. 1111 × 0010 produz 30 sem sinal (0001 1110) ou −2 com sinal (1111 1110). Ambas as metades menos significativas são 1110; apenas as metades mais significativas diferem. Por isso, uma instrução mul serve às duas interpretações.

Acompanhe as decisões de Booth

O algoritmo de Booth opera diretamente com complemento de dois. Dê ao acumulador n + 1 bits e estenda o multiplicando com sinal até essa largura, para que ele e seu negativo caibam. Inicialize o acumulador com zero, coloque o multiplicador em seu registrador de n bits e acrescente um bit extra inicializado com zero.

Examine como um par o bit menos significativo do multiplicador e o bit acrescentado:

Após cada decisão, desloque aritmeticamente à direita todo o registrador formado pelo acumulador, multiplicador e bit extra. Repita n vezes; descarte o bit acrescentado e o bit de sinal redundante mais significativo do acumulador para obter o produto de 2n bits.

Para 2 × (−3), use multiplicando 00010, multiplicador 1101 e acumulador 00000. Os pares são 10, 01, 10, 11. Após as respectivas operações e deslocamentos, acumulador e multiplicador são 11111 0110, 00000 1011, 11111 0101 e 11111 1010. Os oito bits menos significativos do produto 1111 1010 representam −6.

Um deslocamento lógico inseriria zero no extremo mais significativo e corromperia resultados parciais negativos. O bit extra do acumulador também importa: subtrair um multiplicando de n bits com o valor mais negativo exige um valor positivo indisponível em n bits com sinal.

Reduza o trabalho e os caminhos de vai-um

A recodificação de Booth substitui uma sequência de bits iguais a 1 por uma subtração na extremidade menos significativa e uma adição acima da extremidade mais significativa. Por exemplo, 126 é 128 − 2. Bits alternados podem não oferecer economia. Booth de base 4 examina dois bits do multiplicador por etapa e usa dígitos de −2 a +2, reduzindo o número de produtos parciais.

Um multiplicador rápido forma produtos parciais em paralelo. Um somador com salvamento de vai-um comprime três palavras em duas sem propagar sinais de vai-um pela palavra. Árvores de Wallace ou Dadda repetem essa redução e depois usam um somador final com propagação de vai-um. Reduzir 32 linhas a duas leva oito níveis de salvamento de vai-um. A segmentação em pipeline permite que vários produtos estejam em andamento; aceitar um por ciclo não significa que cada um termine em um ciclo.

Para um resultado com sinal reduzido a n bits, cada bit da metade mais significativa deve ser igual ao bit de sinal da metade menos significativa. Em quatro bits, −8 × −1 produz o produto completo 0000 1000. A metade mais significativa é zero, mas o bit de sinal mantido é 1, portanto +8 não cabe no destino com sinal.

A divisão produz um quociente e um resto relacionados por

Para um divisor sem sinal diferente de zero, o resto é não negativo e menor que o divisor. Um dividendo e um divisor de n bits precisam de um quociente e um resto de n bits.

Produza o quociente um bit de cada vez

Leia os bits do dividendo a partir do extremo mais significativo. Dobre o resto parcial, incorpore o próximo bit e teste se o divisor cabe. Se couber, subtraia-o e escreva o bit de quociente 1; caso contrário, mantenha o resto parcial e escreva 0.

Para 0111 dividido por 0010, os restos parciais após incorporar cada bit são 0, 1, 3 e 3. Os dois primeiros são menores que 2, portanto seus bits de quociente são 0. Cada 3 permite uma subtração, deixando resto 1 e bit de quociente 1. O quociente é 0011 e o resto é 0001: 3 × 2 + 1 = 7.

A divisão com restauração tenta primeiro a subtração. Se o resultado da tentativa for negativo, some o divisor de volta e escreva 0; caso contrário, mantenha-o e escreva 1. Detecte a falha com um empréstimo ou uma diferença com sinal de n + 1 bits. Um teste de sinal de n bits não é seguro: em quatro bits, 0 − 9 dá a volta para 0111, cujo bit mais significativo é 0 apesar do empréstimo.

O hardware compacto coloca o dividendo na metade menos significativa de um registrador de 2n bits e o resto parcial na metade mais significativa. Ele desloca à esquerda em cada etapa e insere bits de quociente à direita. Ao final, a metade mais significativa contém o resto e a menos significativa contém o quociente.

A divisão sem restauração leva adiante um resultado de tentativa negativo e soma o divisor durante a etapa seguinte em vez de restaurar imediatamente. Um resto parcial final negativo precisa de uma última soma de volta. A divisão SRT seleciona vários bits de quociente por etapa usando os bits iniciais do divisor e do resto; entradas ausentes em uma tabela de seleção desse tipo causaram o erro FDIV do Pentium em 1994. A divisão continua dependente de cada resto parcial anterior.

Aplique a divisão com sinal por truncamento

Divida os módulos, negue o quociente se os sinais forem diferentes e atribua a um resto diferente de zero o sinal do dividendo.

Esses resultados truncam o quociente em direção a zero e preservam a identidade da divisão. RISC-V, Java e C desde C99 usam essa regra. Em Python, // arredonda para baixo: -7 // 2 é −4 e -7 % 2 é 1.

Trate entradas excepcionais

A divisão por zero no RISC-V retorna um quociente com todos os bits ativados e o dividendo original como resto. O caso de estouro com sinal, o valor mais negativo dividido por −1, retorna o quociente mais negativo e resto zero. Nenhum dos casos gera armadilha. O x86 gera uma exceção de erro de divisão para ambos. O software que precisa informar erros verifica primeiro o zero e também verifica o par que causa estouro com sinal.

Um deslocamento lógico à direita divide valores sem sinal por potências de dois, arredondando para baixo. Um deslocamento aritmético também arredonda valores negativos para baixo: −5 deslocado uma posição à direita torna-se −3, enquanto a divisão por 2 com truncamento produz −2. Para implementar o truncamento com um deslocamento, some $2^k-1$ a uma entrada negativa antes de deslocá-la k posições à direita. Para −5 e k = 1, desloque −4 para obter −2.

Um valor normal de ponto flutuante binário tem a forma

O significando é o valor completo 1,f; a fração armazenada contém apenas f. A normalização garante o 1 inicial, portanto omitir esse bit oculto acrescenta um bit de precisão.

Leia os três campos

O IEEE 754-2019 define esses formatos. Precisão simples e dupla geralmente significam binary32 e binary64. A ordem de armazenamento é sinal, expoente, fração. Para um valor normal, subtraia o viés do campo de expoente sem sinal:

Fração significa a fração binária após a vírgula, não seus bits interpretados como inteiro. Em binary32, campos de expoente de 1 a 254 codificam expoentes de −126 a 127. Os campos 0 e 255 têm significados especiais.

Um viés faz com que expoentes maiores tenham campos sem sinal maiores. Para números positivos finitos, a ordenação sem sinal dos padrões completos segue a ordenação numérica. Valores negativos e NaNs exigem tratamento adicional.

Codifique e decodifique

Para codificar −0,75, escreva seu módulo como ${\mathrm{0,11}}_2={\mathrm{1,1}}_2\times 2^{-1}$. O sinal é 1 e o campo de expoente é −1 + 127 = 126, ou 01111110. Descarte o 1 inicial oculto e preencha a fração com zeros. Os campos são 1 01111110 10000000000000000000000, resultando em 0xBF400000. Em binary64, o mesmo valor é 0xBFE8000000000000.

Para decodificar 0x41460000, divida-o em 0 10000010 10001100000000000000000. O campo de expoente é 130, portanto o expoente real é 3. O significando é

Multiplicar por 8 produz 12,375. Escrever o 1 oculto na fração armazenada alteraria o valor; armazenar −1 diretamente no campo de expoente perderia a regra do viés.

Diferencie intervalo de precisão

O binary32 alcança aproximadamente $\mathrm{3,40}\times {10}^{38}$, com menor normal positivo $2^{-126}$ e cerca de sete algarismos decimais significativos. O binary64 alcança aproximadamente $\mathrm{1,80}\times {10}^{308}$, com menor normal positivo $2^{-1022}$ e cerca de 15 a 16 algarismos significativos. O binary16 tem máximo 65.504, menor normal positivo $2^{-14}$, menor subnormal positivo $2^{-24}$ e cerca de 3,3 algarismos decimais significativos.

A precisão conta algarismos significativos, não algarismos após a vírgula decimal. Por exemplo, binary32 armazena 1.234.567,89 como 1.234.567,875.

No intervalo binary32 de $2^e$ até $2^{e+1}$, valores normais adjacentes são espaçados por $2^{e-23}$. Esse espaçamento é uma ulp, uma unidade na última posição. Logo acima de 1, ele é $2^{-23}$, frequentemente chamado épsilon de máquina. Em $2^{24}$, o espaçamento passa a ser 2, portanto 16.777.217 está ausente mesmo que números muito maiores caibam. Mais bits de expoente ampliam o intervalo de escala; mais bits de fração aproximam os valores representáveis em uma dada escala.

Padrões de expoente reservados permitem que o IEEE 754 represente valores além dos números normalizados comuns. Sempre classifique os campos antes de aplicar uma fórmula de valor.

Reconheça os padrões reservados

O binary32 tem +0 em 0x00000000 e −0 em 0x80000000. Eles são iguais na comparação, mas a divisão pode revelar o sinal: 1 dividido por +0 produz +∞, enquanto 1 dividido por −0 produz −∞. Um resultado negativo minúsculo que é arredondado para zero torna-se −0.

O infinito positivo é 0x7F800000; o maior valor positivo finito é 0x7F7FFFFF. No arredondamento para o mais próximo, o estouro aritmético retorna um infinito com sinal. Dividir um valor finito diferente de zero por zero também retorna infinito com sinal, com outro indicador de exceção. Operações posteriores tratam o infinito de modo consistente: somar 1 a +∞ mantém +∞, multiplicá-lo por −2 produz −∞ e seu recíproco é +0.

Diferencie NaN de infinito

Operações como zero dividido por zero, infinito menos ele mesmo, zero vezes infinito e a raiz quadrada real de −1 não têm resultado numérico significativo. Elas produzem NaN, “não é um número”, e sinalizam operação inválida.

NaN é não ordenado: testes de igualdade e de ordenação menor que ou maior que envolvendo NaN são falsos, enquanto o de desigualdade é verdadeiro. Em particular, x == NaN não detecta NaN. Use isnan(x). NaNs silenciosos normalmente se propagam pelas operações aritméticas; NaNs sinalizadores geram operação inválida quando usados. Nesses formatos binários, o bit mais significativo da fração distingue um NaN silencioso. O NaN silencioso binary32 canônico do RISC-V é 0x7FC00000.

Aproxime-se de zero gradualmente

Um subnormal não tem 1 oculto. Seu expoente é fixado no menor expoente normal:

Para binary32, 0x00000001 é $2^{-149}$ e 0x00400000 é $2^{-127}$. Para binary64, o menor valor positivo é $2^{-1074}$. Usar o expoente menos o viés com um campo de expoente zero produziria um erro de um fator de dois, mesmo antes de acrescentar incorretamente um 1 oculto.

Os subnormais proporcionam subfluxo gradual: a precisão diminui à medida que os valores diminuem, com espaçamento absoluto fixo perto de zero. Valores finitos distintos em um formato ainda têm uma diferença representável diferente de zero. Modos de substituição por zero descartam essa proteção e podem acelerar o tratamento de subnormais em alguns processadores.

Leia os indicadores de exceção

O IEEE 754 define operação inválida, divisão por zero, estouro, subfluxo e resultado inexato. O tratamento padrão retorna um resultado e registra o estado; ele não precisa interromper a execução. Resultado inexato significa que o resultado arredondado difere do resultado exato.

No tratamento padrão, o subfluxo exige que o resultado seja minúsculo e inexato. Em binary32, $2^{-126}\mathrm{/}2=2^{-127}$ é um subnormal exato e não ativa o indicador de subfluxo. O RISC-V registra NV, DZ, OF, UF e NX em fflags dentro de fcsr, e exceções de ponto flutuante não acionam armadilhas aritméticas. Um infinito retornado sozinho não identifica se ocorreu estouro ou divisão por zero; examine o indicador.

A aritmética de ponto flutuante opera separadamente sobre significandos e expoentes. O resultado final deve ser o resultado exato da operação arredondado para o formato de destino, portanto a movimentação intermediária de bits deve preservar informações suficientes para essa última decisão.

Some com um expoente compartilhado

A adição segue quatro estágios: alinhar, operar, normalizar, arredondar. Compare os expoentes e desloque o significando do menor operando à direita pela diferença entre eles. Some os módulos para sinais iguais; subtraia os módulos para sinais opostos. Desloque o resultado para a forma normalizada e ajuste seu expoente. Depois arredonde, normalizando novamente se o arredondamento criar um vai-um.

Use significandos de quatro bits para examinar 0,5 + (−0,4375):

1. Escreva os operandos como ${\mathrm{1,000}}_2\times 2^{-1}$ e $-{\mathrm{1,110}}_2\times 2^{-2}$.
2. Alinhe o segundo para $-{\mathrm{0,111}}_2\times 2^{-1}$.
3. Subtraia os módulos: ${\mathrm{1,000}}_2-{\mathrm{0,111}}_2={\mathrm{0,001}}_2$.
4. Normalize para ${\mathrm{1,000}}_2\times 2^{-4}$, ou 0,0625. Nenhum bit diferente de zero foi perdido, portanto nenhuma alteração por arredondamento é necessária.

O cancelamento pode exigir um grande deslocamento de normalização à esquerda. O hardware usa um subtrator de expoentes, um deslocador de alinhamento, um somador de significandos, um contador de zeros à esquerda e lógica de normalização e arredondamento. Somadores de ponto flutuante geralmente são segmentados em pipeline ao longo de vários ciclos.

Um modelo decimal mostra por que algarismos extras importam: com quatro algarismos significativos, 99,99 + 0,161 é alinhado como $\mathrm{9,999}+\mathrm{0,01610}$ na escala ${10}^1$. O resultado intermediário exato é 10,01510 nessa escala. Normalize para $\mathrm{1,00151}\times {10}^2$ e arredonde para $\mathrm{1,002}\times {10}^2$. Cortar a parcela alinhada cedo demais perderia informações necessárias para escolher 100,2.

Multiplique escalas e significandos

Multiplique os significandos, some os expoentes reais e aplique XOR aos sinais. Com campos com viés, subtraia o viés uma vez:

antes dos ajustes de normalização. Dois significandos normais multiplicados produzem um valor de 1 até 4, portanto seu produto precisa de no máximo um deslocamento de normalização à direita. O arredondamento pode exigir outro ajuste; os limites do expoente também precisam ser verificados.

Para 0,5 × (−0,4375), os campos de expoente binary32 fornecem 126 + 125 − 127 = 124, ou expoente real −3. O produto dos significandos é ${\mathrm{1,000}}_2\times {\mathrm{1,110}}_2={\mathrm{1,110}}_2$. O XOR dos sinais é 1, produzindo $-{\mathrm{1,110}}_2\times 2^{-3}=-\mathrm{0,21875}$.

Arredonde uma vez com multiplicação e adição fundidas

A FMA calcula a × b + c com um arredondamento após a expressão completa. A multiplicação e a adição separadas arredondam duas vezes. Em binary32, considere $a=1+2^{-23}$, $b=1-2^{-23}$ e c = −1. Seu produto exato é $1-2^{-46}$. Uma multiplicação separada o arredonda para 1, portanto a adição retorna zero. A FMA mantém a pequena diferença do produto e retorna $-2^{-46}$.

A extensão F do RISC-V fornece 32 registradores de ponto flutuante, de f0 a f31; D amplia o mesmo banco para precisão dupla. flw/fsw e fld/fsd transferem valores. As operações aritméticas incluem fadd.s, fmul.s, fdiv.s e fsqrt.s, com formas .d para precisão dupla. fmadd.s calcula multiplicação e adição fundidas. Comparações como flt.s gravam 0 ou 1 em um registrador de inteiros, e fcvt converte formatos ou valores inteiros.

Um formato finito não pode armazenar todo resultado exato. Arredondamento correto significa escolher o resultado representável exigido pela direção de arredondamento, como se a operação tivesse sido primeiro calculada exatamente. A aritmética básica, a raiz quadrada e a FMA obedecem a essa regra. Os bits de conteúdo e de sinal de NaN não precisam ser idênticos entre processadores.

Escolha uma direção de arredondamento

As quatro primeiras são exigidas para implementações binárias; o desempate para o par é o padrão. O desempate para longe de zero é exigido para formatos decimais, e o RISC-V também o fornece para operações binárias. Seus nomes são RNE, RUP, RDN, RTZ e RMM; uma instrução pode selecionar um modo diretamente ou usar o modo dinâmico em fcsr.

Para desempate para o par ao arredondar para inteiros, 2,5 torna-se 2 e 3,5 torna-se 4. Em binário, com significandos de quatro bits, ${\mathrm{1,0011}}_2$ é arredondado para ${\mathrm{1,010}}_2$, e ${\mathrm{1,0101}}_2$ também é arredondado para ${\mathrm{1,010}}_2$. O bit par pertence ao significando mantido, não ao expoente ou a um algarismo decimal exibido.

Mantenha informações de guarda, arredondamento e aderência

Após a normalização, mantenha dois bits adicionais além do significando de destino: guarda e arredondamento. O bit de aderência é o OR de todos os bits descartados posteriores. Ele registra se toda essa parte restante é zero.

Para arredondamento ao mais próximo, guarda 0 significa abaixo da metade. Guarda 1 com arredondamento ou aderência igual a 1 significa acima da metade. Guarda 1 com os dois indicadores posteriores iguais a 0 significa um empate exato. Em um empate, incremente o significando mantido somente se seu bit menos significativo atual for 1.

Para uma soma de 8 + 0,5625 com significandos de quatro bits, o alinhamento fornece

Mantenha 1.000; guarda é 1, arredondamento é 0 e aderência é 1 porque a parte restante contém um 1. O valor está acima da metade, portanto incremente para ${\mathrm{1,001}}_2\times 2^3=9$. Descartar a aderência transformaria isso falsamente em um empate e escolheria 8.

Um bit de aderência é uma evidência sobre todos os bits perdidos, não apenas o terceiro bit após a parte mantida. Durante o deslocamento, quando algum bit perdido é 1, o estado de aderência permanece em 1 para essa parte acumulada.

Interprete erro e estouro

Para resultados finitos dentro do intervalo, o arredondamento para o mais próximo tem erro absoluto de no máximo meia ulp; o arredondamento direcionado tem erro menor que uma ulp. Para resultados normais binary32, o limite relativo usual do arredondamento para o mais próximo é $2^{-24}$; para binary64, é $2^{-53}$. Resultados subnormais exigem raciocínio com erro absoluto porque sua precisão relativa diminui.

A direção de arredondamento também controla os resultados de estouro. Um estouro positivo produz +∞ no arredondamento para o mais próximo ou em direção ao positivo, mas o maior valor positivo finito no arredondamento em direção a zero ou ao negativo. Um estouro negativo produz o comportamento inverso.

Conversões para inteiros têm regras próprias. Em C, conversões representáveis como (int)2.7 e (int)-2.7 truncam para 2 e −2, independentemente da direção atual de arredondamento em ponto flutuante. Verifique o intervalo de destino e a parte fracionária descartada.

Erros de ponto flutuante frequentemente decorrem diretamente do espaçamento finito. Separe o erro já presente nos operandos armazenados do arredondamento realizado por uma operação e da informação perdida durante uma conversão.

Identifique o erro de representação

Uma fração irredutível tem expansão binária finita exatamente quando seu denominador é uma potência de dois. Valores como 0,5, 0,25 e 0,375 são exatos. A expansão de 0,1 se repete, portanto binary32 armazena 0x3DCCCCCD, cerca de 0,10000000149011612. binary64 também armazena uma aproximação.

Consequentemente, 0.1 + 0.2 em binary64 produz 0,30000000000000004, diferente do valor armazenado mais próximo de 0,3. Um resultado curto exibido, como 0.1, pode ser o menor decimal que, convertido de volta, produz os mesmos bits armazenados; isso não estabelece exatidão.

Para resultados finitos aproximados, use uma tolerância escolhida para o problema, por exemplo

A tolerância absoluta trata valores próximos de zero; a tolerância relativa varia com o módulo. As tolerâncias devem refletir o cálculo e o erro aceitável, não apenas o número de algarismos exibidos.

Observe a adição perder uma entrada pequena

A absorção ocorre no arredondamento para o mais próximo quando uma pequena parcela não consegue mover um operando grande para seu próximo vizinho representável. Em binary32, 16.777.216 + 1 é arredondado de volta para 16.777.216: os valores vizinhos estão separados por dois, e esse empate seleciona o significando par. Um contador float que soma 1 pode, portanto, parar de avançar.

Alterar a ordem da adição pode alterar a resposta. Com binary32, x = −1,5 × 10³⁸, y = 1,5 × 10³⁸ e z = 1, (x + y) + z produz 1. Mas y + z é arredondado para y, portanto x + (y + z) produz zero. A adição não é associativa. Reduções paralelas podem mudar seu agrupamento quando a quantidade de threads muda, afetando os bits finais.

O arredondamento repetido também se acumula: somar 0,1 em binary32 dez milhões de vezes a um total binary32 produz 1.087.937 em vez de 1.000.000. Um acumulador mais largo reduz a perda por arredondamento. Somar primeiro módulos menores também pode preservar contribuições que um total acumulado grande absorveria.

Separe cancelamento de subtração inexata

O cancelamento remove algarismos iniciais comuns de operandos quase iguais. A subtração em si pode ser exata enquanto erros anteriores dos operandos se tornam grandes em relação à resposta pequena. Em binary32, 1,0000001 é armazenado como $1+2^{-23}$. Subtrair 1 produz cerca de $\mathrm{1,1920929}\times {10}^{-7}$ em vez de $\mathrm{1,0}\times {10}^{-7}$, aproximadamente 19% de erro relativo.

Verifique conversões e escolhas de formato

binary64 representa exatamente todo inteiro de 32 bits. binary32 não: 16.777.217 é arredondado para 16.777.216 no desempate para o par. Acima de $2^{53}$, binary64 também deixa de representar alguns inteiros. Converter um valor de ponto flutuante para um tipo inteiro menor pode ultrapassar completamente seu intervalo.

No primeiro voo do Ariane 5, em 1996, uma conversão fora do intervalo de ponto flutuante de 64 bits para um inteiro com sinal de 16 bits desligou os sistemas de referência inercial e contribuiu para a perda do foguete. Na falha do Patriot em 1991, em Dhahran, uma aproximação truncada de 0,1 em ponto fixo acumulou cerca de 0,34 s de erro de tempo após cerca de 100 horas, deslocando a janela de rastreamento em cerca de 687 m. Esse foi um erro de representação em ponto fixo, não uma operação IEEE de ponto flutuante.

Escolha binary64 para maior precisão de uso geral, binary32 quando seu menor uso de memória for adequado à tarefa e binary16 ou bfloat16 para cargas de trabalho adequadas de baixa precisão. bfloat16 tem oito bits de expoente e sete de fração. Valores monetários exatos pertencem a unidades monetárias menores expressas em inteiros ou a um tipo decimal.