Aritmética de ponto flutuante — por que calculadoras mostram decimais estranhos

Uma calculadora online dá uma resposta limpa para um cálculo decimal e uma sequência de dígitos inesperados para o próximo. A diferença não é aleatória e não é um defeito de software — é uma consequência previsível de como a aritmética de ponto flutuante representa números em binário. Quando você entende o sistema, as surpresas ficam claras: você pode identificar de relance quais resultados esperar exatamente e quais terão um pequeno erro oculto.

O padrão por trás de toda calculadora baseada em navegador: IEEE 754

Todo grande linguagem de programação, e todo navegador que roda JavaScript, armazena números decimais segundo o padrão IEEE 754 para aritmética de ponto flutuante binária, publicado pela primeira vez em 1985 pelo Institute of Electrical and Electronics Engineers. A versão atual, IEEE 754-2019, foi publicada em julho de 2019. Quase todas as unidades de ponto flutuante de hardware, de processadores de laptops a smartphones, implementam esse padrão.

Calculadoras online — incluindo a acima — usam a variante específica chamada precisão dupla (binary64): 64 bits por número, com 53 bits dedicados aos dígitos significativos e o restante codificando a escala (o expoente). Esse significando de 53 bits oferece aproximadamente 15 a 17 dígitos decimais significativos de precisão. Para a maioria dos usos cotidianos isso é mais do que suficiente — mas o formato impõe uma limitação estrutural que às vezes aparece como saída inesperada.

A causa raiz: frações binárias não podem representar todos os decimais exatamente

Um computador trabalha na base 2. Todo número que ele armazena é construído a partir de potências de 2: 1/2, 1/4, 1/8, 1/16…. Qualquer fração decimal que possa ser expressa como uma soma finita dessas potências — como 0,5 (= 1/2), 0,25 (= 1/4) ou 0,125 (= 1/8) — é armazenada exatamente. Toda outra fração decimal requer uma sequência binária infinita, que o formato de 64 bits deve arredondar para o valor representável mais próximo.

A situação é diretamente análoga à notação decimal e frações de 3. Você não pode escrever 1/3 exatamente em decimal — é 0,333333… para sempre. Você arredonda para um número de casas e aceita um pequeno erro. A aritmética de ponto flutuante faz o mesmo, mas na base 2, e as frações que causam problema são diferentes: 1/5 (= 0,2), 1/10 (= 0,1) e 3/10 (= 0,3) são todas frações infinitas repetidas em binário.

Diagrama comparando frações decimais que são exatas em binário versus aquelas que requerem sequências binárias infinitas e devem ser arredondadas

Como erros de arredondamento se acumulam em cálculos

Um único valor arredondado introduz um erro tão pequeno — tipicamente na 16ª ou 17ª casa decimal — que é invisível no uso cotidiano. O problema cresce quando múltiplos valores arredondados interagem numa cadeia de operações. Cada passo pode amplificar o erro ou acabar cancelando-o, e o resultado nem sempre é previsível só pela inspeção.

Alguns padrões que tendem a mostrar dígitos inesperados:

Somar muitos decimais — somar dez valores como 0,1 cada dá 0.9999999999999999 em vez de exatamente 1, porque o erro de arredondamento em cada 0,1 se acumula.
Multiplicar por números próximos de 1 — 1.1 × 3 retorna 3.3000000000000003 em JavaScript; a pequena superestimação de 1,1 em binário é ampliada pela multiplicação.
Subtração de números quase iguais (cancelamento catastrófico) — subtrair dois valores próximos pode perder muitos dígitos significativos: 1.0000000000000002 - 1 revela a diferença que normalmente seria invisível.
Operações repetidas — divisão seguida de multiplicação pelo mesmo valor nem sempre retorna o número original exatamente, porque cada passo introduz seu próprio arredondamento.

Exemplos que você pode testar na calculadora acima

A calculadora acima usa o motor nativo de ponto flutuante de 64 bits do JavaScript — nenhum arredondamento extra é aplicado além de Math.round(result * 1e10) / 1e10, que suaviza erros na décima casa decimal mas deixa visível qualquer coisa além disso. Isso a torna uma janela confiável para o comportamento real do ponto flutuante.

0.1 + 0.2 → 0.30000000000000004 (o caso mais famoso)
1.1 × 3 → 3.3000000000000003
0.1 × 0.1 → 0.010000000000000002
1 ÷ 3 × 3 → 1 (erros se cancelam neste caso)
0.5 + 0.25 → 0.75 (exato — ambos são potências de dois)

Note que os resultados "limpos" aparecem exatamente onde os valores envolvidos são frações binárias exatas. Os dígitos inesperados aparecem onde não são.

O que o limite de precisão significa na prática

A precisão dupla IEEE 754 oferece cerca de 15 a 17 dígitos decimais significativos antes que qualquer arredondamento seja forçado. Para a grande maioria dos usos essa precisão é enorme: uma medida precisa até 10 casas decimais, um valor financeiro com 14 dígitos significativos ou uma constante física usada em cálculo de engenharia estão confortavelmente dentro desse intervalo.

As situações onde o limite importa:

Software financeiro — cálculos de moeda acumulam pequenos erros de arredondamento em milhões de transações. Sistemas financeiros em produção usam aritmética de ponto fixo (inteiros representando centavos inteiros) em vez de ponto flutuante para evitar isso completamente.
Simulações científicas — métodos numéricos de longa duração (modelos climáticos, dinâmica dos fluidos) acumulam arredondamentos em milhões de passos; pesquisadores usam precisão estendida ou bibliotecas numéricas dedicadas.
Comparações de igualdade em código — perguntar "esse resultado é exatamente 0,3?" quase sempre está errado; a prática padrão é verificar se o resultado está dentro de uma pequena tolerância de 0,3.

Como contornar surpresas do ponto flutuante

Para cálculos do dia a dia — o erro está na 16ª casa decimal e não tem impacto prático. Confie no resultado.
Para trabalho financeiro em calculadora geral — arredonde o resultado final para o número necessário de casas decimais (ex.: 2 para moeda) e considere apenas o valor arredondado como significativo.
Para verificar se um erro é de ponto flutuante — insira a mesma expressão numa sessão nova e compare; erros de ponto flutuante são determinísticos, então a resposta será idêntica toda vez para a mesma expressão.
Para identificar entradas seguras — valores que são frações exatas de potências de 2 (0,5, 0,25, 0,125, 0,0625…) ou inteiros são sempre armazenados exatamente. Se você conseguir reformular seu problema nesses termos, elimina a fonte do erro.

Veja por si mesmo: digite 1.1 × 3 na calculadora acima, depois 0.5 × 3. O primeiro dá uma pequena cauda de dígitos inesperados; o segundo dá um 1,5 limpo. Esse contraste resume toda a história do ponto flutuante: entradas binárias exatas, respostas binárias exatas; entradas não binárias exatas, arredondamento no limite da precisão.