Calculadora de ponto flutuante
Converta números decimais para representação binária IEEE 754 e analise a precisão.
Digite qualquer número decimal e selecione um formato de precisão para ver sua representação binária IEEE 754, expoente, mantissa e erro de arredondamento.
Calculadora de ponto flutuante
Converta números decimais para representação binária IEEE 754 e analise a precisão.
Exemplos
Clique em qualquer botão abaixo para carregar uma constante numérica conhecida.
| Entrada decimal | Precisão e notas | Significado |
|---|---|---|
| 3.141592653589793 (dupla) | Sinal: 0 · Exp: 1 · Dígitos exatos: ~15 | π — irracional, armazenado com um pequeno erro de arredondamento |
| 0.1 (simples) | Sinal: 0 · Armazenado: 0.100000001490116 · Erro: ~1.49e-9 | Exemplo clássico de erro de arredondamento |
| 2.718281828459045 (dupla) | Sinal: 0 · Exp: 1 · Dígitos exatos: ~15 | Número e de Euler |
| 1.23e-10 (simples) | Sinal: 0 · Normalizado · Pequeno valor positivo | Testa a precisão de números pequenos no formato simples |
Sobre a calculadora de ponto flutuante
A calculadora de ponto flutuante converte números decimais em sua representação binária de ponto flutuante IEEE 754 e mostra o detalhamento completo em nível de bits, incluindo sinal, expoente e mantissa. Entender a representação em ponto flutuante é fundamental para cientistas da computação, engenheiros de software, analistas numéricos e qualquer pessoa que trabalhe com computadores em contextos onde a precisão aritmética importa.
O padrão IEEE 754, publicado pelo Institute of Electrical and Electronics Engineers em 1985 e revisado em 2008, define o formato de aritmética de ponto flutuante usado em praticamente todos os processadores e linguagens modernas, incluindo C, C++, Java, Python e JavaScript. O padrão especifica dois formatos principais: precisão simples (32 bits) e precisão dupla (64 bits).
Um float de precisão simples de 32 bits consiste em três campos: 1 bit de sinal, 8 bits de expoente e 23 bits de mantissa (significando). O bit de sinal é 0 para números positivos e 1 para números negativos. O expoente é armazenado com um viés de 127, o que significa que o expoente real é o valor armazenado menos 127, permitindo representar expoentes positivos e negativos usando inteiros sem sinal. A mantissa armazena os bits fracionários do significando normalizado, com um 1 inicial implícito (o bit oculto) fornecendo um bit extra de precisão efetiva.
Um float de precisão dupla de 64 bits usa 1 bit de sinal, 11 bits de expoente (viés de 1023) e 52 bits de mantissa, fornecendo aproximadamente 15–17 dígitos decimais significativos em comparação com os 6–7 dígitos da precisão simples. A precisão dupla é o tipo de ponto flutuante padrão na maioria das linguagens de programação.
Um ponto importante é que muitos números decimais aparentemente simples — como 0.1 — não podem ser representados exatamente em ponto flutuante binário. O decimal 0.1 em binário é a fração periódica 0.0001100110011..., que precisa ser truncada para caber em 23 ou 52 bits de mantissa. Esse truncamento introduz um pequeno erro de arredondamento, e é por isso que 0.1 + 0.2 não é exatamente 0.3 na maioria das linguagens. Esta calculadora mostra o valor armazenado exato e o erro de arredondamento de qualquer número decimal que você inserir, tornando-se uma ferramenta valiosa de depuração e aprendizado.
Como usar esta calculadora
- Escolha o formato de precisão — simples (32 bits) para aplicativos embarcados ou GPU, dupla (64 bits) para computação científica.
- Digite qualquer número decimal no campo de entrada. A notação científica é aceita (ex.: 1.23e-10 ou 6.022e23).
- Clique em 'Converter' para ver o detalhamento completo do IEEE 754: bit de sinal, bits do expoente (com valores com viés e real) e bits da mantissa.
- Revise o valor armazenado — o decimal exato usado pelo computador — e compare com sua entrada para ver qualquer erro de arredondamento.
- Use os botões de exemplo para explorar como constantes conhecidas como π, e ou 0.1 são representadas em ponto flutuante binário.
Perguntas frequentes
Por que 0.1 não pode ser representado exatamente em ponto flutuante?
O decimal 0.1 em binário é uma fração periódica infinita (0.000110011001100...), assim como 1/3 é um decimal repetido. Como um float tem um número fixo de bits, a fração precisa ser truncada, introduzindo um pequeno erro de arredondamento. É por isso que, na maioria das linguagens, 0.1 + 0.2 resulta em aproximadamente 0.30000000000000004 em vez de exatamente 0.3.
O que é o viés no campo do expoente?
O viés é um deslocamento fixo adicionado ao expoente real antes de ser armazenado. Precisão simples usa viés 127 e precisão dupla usa 1023. Se o expoente real é 3, o valor armazenado em simples é 3 + 127 = 130. Essa representação com viés permite expoentes de −126 a +127 (simples) ou de −1022 a +1023 (dupla) usando apenas inteiros sem sinal.
O que é o bit oculto?
Para números de ponto flutuante normalizados, o bit inicial da mantissa é sempre 1 e não é armazenado — ele é implícito. Esse bit 'oculto' ou 'implícito' dá à precisão simples 24 bits de precisão de mantissa (23 armazenados + 1 oculto) e à precisão dupla 53 bits (52 armazenados + 1 oculto). Números desnormalizados próximos de zero têm um 0 inicial implícito.
Quais são os valores especiais da IEEE 754?
A IEEE 754 define vários valores especiais: zero positivo e negativo (distinguidos pelo bit de sinal), infinito positivo e negativo (todos os bits do expoente em 1, todos os bits da mantissa em 0) e NaN — Not a Number (todos os bits do expoente em 1 e pelo menos um bit da mantissa em 1). Esses valores permitem lidar com overflow, divisão por zero e operações indefinidas sem travar os programas.
Quando devo usar precisão simples versus dupla?
Use precisão dupla (64 bits) para computação científica, cálculos financeiros e qualquer aplicação que exija mais de 7 dígitos decimais de precisão. Use precisão simples (32 bits) quando memória ou desempenho forem limitados — GPUs processam floats de precisão simples muito mais rápido, e sistemas móveis/embarcados costumam preferir 32 bits por eficiência. Os erros de arredondamento em precisão simples podem se acumular significativamente em algoritmos iterativos.
Como evito erros de precisão de ponto flutuante no meu código?
Para comparações de igualdade, use uma tolerância (epsilon) em vez de igualdade exata: |a − b| < 1e-9 em vez de a === b. Para cálculos financeiros, considere usar aritmética inteira (por exemplo, armazenar valores em centavos) ou uma biblioteca decimal dedicada. Para computação científica, use algoritmos de soma compensada como a soma de Kahan para reduzir erros de arredondamento acumulados em somas grandes.