Conversor IEEE 754 de Ponto Flutuante

O Que É Ponto Flutuante IEEE 754?

// Float ↔ hex through the raw IEEE 754 bits (works in any browser / Node.js)
const buf = new DataView(new ArrayBuffer(8));

function floatToHex32(value) {
  buf.setFloat32(0, value); // rounds to nearest even
  return '0x' + buf.getUint32(0).toString(16).toUpperCase().padStart(8, '0');
}

function hexToFloat32(hex) {
  buf.setUint32(0, parseInt(hex, 16));
  return buf.getFloat32(0);
}

floatToHex32(0.1);        // '0x3DCCCCCD'
floatToHex32(3.14159);    // '0x40490FD0'
hexToFloat32('3DCCCCCD'); // 0.10000000149011612

Recursos Principais

Exemplos de Conversão IEEE 754

0.1

0x3DCCCCCD — armazenado na verdade como 0.100000001490116119384765625

3.14159

0x40490FD0

65504

0x7BFF — o maior valor finito do FP16

-0

0x80000000 (FP32), enquanto +0 é 0x00000000

Como Converter Números de Ponto Flutuante IEEE 754

1. 1

   Escolha um formato de ponto flutuante

   Simples (FP32) vem pré-selecionado. Mude para Dupla (FP64) para números no estilo JavaScript/Python, ou para Meia (FP16) e bfloat16, os formatos de 16 bits usados em aprendizado de máquina e computação gráfica.

2. 2

   Digite um número decimal

   Insira qualquer valor — 0.1, -2.5e3, 65504 — ou use os chips de valores especiais para ±0, ±Infinity, NaN, o menor subnormal e o maior valor finito. A conversão acontece enquanto você digita.

3. 3

   Leia o layout de bits com código de cores

   O bit de sinal, o campo do expoente e a mantissa são destacados em cores diferentes, com a tabela de detalhamento dos campos mostrando os bits brutos, a aritmética do viés e o bit inicial implícito.

4. 4

   Confira o valor armazenado exato e o erro

   O painel de precisão imprime o valor realmente armazenado — todos os dígitos, calculados de forma exata — ao lado do erro de arredondamento em relação ao que você digitou, além dos vizinhos representáveis anterior e seguinte e do intervalo em ULP.

5. 5

   Inverta bits, cole hex, copie os resultados

   Clique em qualquer bit para invertê-lo, ou cole strings hex (3DCCCCCD) e binárias para decodificá-las de volta a decimal. Copie o hex, o binário, o valor exato ou um link compartilhável que reproduz o padrão de bits exato.

Erros Comuns de Ponto Flutuante

print(0.1)  # 0.1 — parece exato, não é

0.1 armazenado (FP64) = 0.1000000000000000055511151231257827021181583404541015625

if (0.1 + 0.2 === 0.3) { … }   // nunca executa

if (Math.abs(a - b) < 1e-9) { … }   // tolerância dimensionada aos seus dados

fp16(65520)   → Infinity (0x7C00) — estouro silencioso

bf16(65520)   → finito (o bfloat16 mantém 8 bits de expoente)

if (x === NaN) { … }        // sempre falso, mesmo quando x É NaN

if (Number.isNaN(x)) { … }  // o teste correto

O Que Você Pode Fazer com o Conversor IEEE 754

Depure dados binários serializados

Cole o hex que você encontrou em uma captura de rede, buffer de GPU, dump de registradores ou formato de arquivo e decodifique-o para o valor decimal exato — ou vá no sentido contrário para escrever fixtures de teste. Nota sobre ordem de bytes: o hex mostrado é o padrão de bits big-endian; se o seu dump for little-endian, inverta a ordem dos bytes antes de colar.

Entenda a quantização em ML

Verifique se os seus valores sobrevivem ao teto de 65504 do FP16, compare a perda de precisão do FP16 contra o bfloat16 dígito por dígito e inspecione a faixa subnormal em que gradientes sofrem underflow.

Explique um bug de ponto flutuante

Quando um colega perguntar por que dois números 'iguais' diferem, envie um permalink mostrando os dois padrões de bits e os valores armazenados exatos — a discussão se resolve sozinha. Combine com a ferramenta de comparação de texto para dumps mais longos.

Aprenda ou ensine a codificação

O conteúdo de arquitetura de computadores fica concreto quando os alunos podem clicar nos bits do expoente e ver a aritmética do viés se atualizar. A tabela de detalhamento dos campos espelha a forma como os livros didáticos desenham o formato.

Decodifique registradores embarcados e industriais

Cargas de Modbus, CAN e sensores rotineiramente transportam valores FP32 como palavras hex brutas. Cole a palavra aqui para ler o valor físico sem escrever um script descartável.

Formatos IEEE 754 e Valores Especiais

Os quatro formatos binários em resumo

binary16 (FP16): 1 bit de sinal + 5 de expoente + 10 de mantissa, viés 15, máximo 65504, ~3.3 dígitos decimais. bfloat16: 1 + 8 + 7, viés 127, máximo ≈ 3.39 × 10³⁸, ~2.3 dígitos. binary32 (FP32): 1 + 8 + 23, viés 127, máximo ≈ 3.40 × 10³⁸, ~7.2 dígitos. binary64 (FP64): 1 + 11 + 52, viés 1023, máximo ≈ 1.80 × 10³⁰⁸, ~15.9 dígitos. O padrão: bits de expoente compram alcance, bits de mantissa compram precisão, e o bfloat16 troca deliberadamente toda a sua precisão pelo alcance do FP32.

Como um valor é montado

Um número normal decodifica como (−1)^sinal × 1.mantissa × 2^(expoente − viés). O 1 inicial é implícito — ele não é armazenado, e é por isso que um campo de mantissa de 23 bits entrega 24 bits de precisão. O expoente armazenado é o expoente verdadeiro mais o viés (127 no FP32), então 2⁰ é armazenado como 01111111. A tabela de detalhamento dos campos nesta ferramenta mostra cada etapa dessa aritmética para o valor atual.

Valores especiais: os padrões de expoente reservados

Expoente todo em uns com mantissa zero é ±Infinity; com qualquer mantissa diferente de zero é NaN (o NaN silencioso canônico aciona o bit mais alto da mantissa). Expoente todo em zeros com mantissa zero é ±0; com mantissa diferente de zero é um subnormal, decodificado como 0.mantissa × 2^(1 − viés) — sem o 1 inicial implícito. Essas regras são idênticas nos quatro formatos, e é por isso que os mesmos chips funcionam em cada um.

Arredondamento: para o mais próximo, empates para o par

Quando um valor cai entre dois números representáveis, o modo padrão do IEEE 754 arredonda para o mais próximo; em um empate exato, escolhe aquele cujo último bit da mantissa é 0 (empates para o par), o que evita deriva sistemática. Este conversor aplica exatamente essa regra ao estreitar sua entrada decimal para o formato de destino, e o painel de erro mostra a diferença resultante, com sinal, de forma exata.

ULP: o espaçamento de grade dos floats

Os floats representáveis não estão distribuídos uniformemente — o intervalo entre vizinhos (uma unidade na última casa) dobra a cada potência de dois. Perto de 1.0 o ULP de um double é 2⁻⁵² ≈ 2.22 × 10⁻¹⁶; perto de 2⁵³ o ULP chega a 1.0 e os inteiros começam a pular. O painel de vizinhos imprime o ULP atual de forma exata, que é a resposta honesta a 'quão preciso é meu número aqui?'.

Boas Práticas de Ponto Flutuante

Nunca compare floats com ==

Depois de qualquer aritmética, duas expressões matematicamente iguais podem ficar a um ULP de distância. Compare contra uma tolerância adequada às suas magnitudes — ou conte ULPs entre os padrões de bits, que esta ferramenta permite inspecionar diretamente.

Mantenha dinheiro fora de floats binários

Nenhuma grade de potências de dois contém 0.10 exatamente, então moeda em floats acumula erros visíveis. Use centavos inteiros ou um tipo decimal; o painel de valor armazenado exato aqui é a prova permanente do porquê.

Escolha o formato de 16 bits pelo alcance, não pelo hábito

Se os seus valores podem passar de 65504 — perdas, gradientes, picos de física — o FP16 vai estourar para Infinity onde o bfloat16 segue adiante. Se tudo está normalizado em uma faixa estreita, os bits extras de mantissa do FP16 dão precisão visivelmente melhor.

Cuidado com a armadilha do arredondamento duplo ao estreitar

Converter decimal → double → half pode cair a um ULP de distância de converter decimal → half diretamente, em raros casos de meio caminho. Esta ferramenta arredonda sua entrada decimal para o formato de destino em uma única etapa, então o que você vê é a resposta IEEE 754 honesta.

Espere que inteiros quebrem acima de 2⁵³

Um double armazena exatamente todo inteiro até 2⁵³ e depois começa a pular — 2⁵³ + 1 não é representável. Se você lida com IDs ou contadores perto dessa escala, use inteiros de 64 bits ou strings, e confira valores suspeitos aqui em nível de bits.

Perguntas Frequentes sobre o Conversor IEEE 754