Float dupla precisão para bits
Veja exatamente como o computador guarda um decimal em dupla precisão: o 1 vira 3FF0000000000000, com bit de sinal 0, expoente 1023 e os 52 bits da mantissa zerados. Zeros, subnormais, infinitos e NaN recebem um rótulo próprio. Grátis no seu navegador.
- Grátis
- Funciona no seu navegador
- Sem cadastro
- Seus dados não saem do seu aparelho
Executar grátis
Exemplo resolvido
- Valor
- 1
- Formato de saída
- binary64
- Bits
- 64
- Hex
- 3FF0000000000000
- Hexadecimal com prefixo
- 0x3FF0000000000000
Informe um decimal como um, menos três ponto cinco ou um valor científico, e a ferramenta devolve a palavra hexadecimal canônica de dezesseis dígitos, a string binária completa de sessenta e quatro bits, o bit de sinal, o campo de expoente enviesado de onze bits, a mantissa de cinquenta e dois bits, o expoente sem viés quando definido, e um rótulo de categoria para números normais, subnormais, zeros com sinal, infinitos e NaN. Dumps de firmware, rastros de rede, runtimes de linguagem e exercícios de livro compartilham este layout determinístico binary64.
O que os 64 bits de um número guardam
Um valor binary64 ocupa exatamente sessenta e quatro bits dispostos como um bit de sinal, onze bits de expoente com viés mil vinte e três, e cinquenta e dois bits explícitos de mantissa (o campo fração ou significando) com um um líder implícito em números normais. O bit de sinal é zero para valores não negativos e um para valores negativos, incluindo o zero negativo.
O campo de expoente enviesado codifica a verdadeira potência de dois como inteiro sem sinal: em números normais o expoente sem viés é o campo enviesado menos mil vinte e três.
Padrões especiais reutilizam o mesmo layout sem tag separada: expoente de todos uns com mantissa zero é infinito com sinal; expoente de todos uns com mantissa diferente de zero é um NaN; expoente de todos zeros com mantissa zero é zero com sinal; expoente de todos zeros com mantissa diferente de zero é um número subnormal que preenche o vão perto de zero.
Esta capacidade mira sempre apenas binary64—não muda para precisão simples de trinta e dois bits—assim cada resposta tem largura de campo fixa que você pode documentar em protocolos, serializadores e gabaritos de prova. A codificação usa ordem de bytes big-endian via DataView, alinhada à convenção de rede e de livro do bit mais significativo primeiro, de modo que o primeiro nibble hex é sempre o extremo alto da palavra e o primeiro dígito binário é sempre o sinal.
Onde enxergar os bits faz diferença
Programadores de sistemas e engenheiros embarcados usam uma ferramenta de float de dupla precisão para bits ao confrontar dumps de memória, formatos de fio e registradores do depurador com valores decimais sem montar um desmontador completo. Autores de linguagens e bibliotecas fixam codificações douradas em testes unitários de serializadores, sementes de hash e intercâmbio de ponto flutuante multiplataforma para a CI falhar quando uma plataforma muda o arredondamento em silêncio.
Pipelines de dados e ML às vezes precisam provar que uma palavra binary64 armazenada coincide com uma constante documentada como pi ou com uma carga NaN silenciosa sentinela ao auditar cargas parquet ou protobuf. Validação falha não consome saldo.
Casos de uso
Dumps de firmware e protocolos
Confronte um double decimal com hex binary64 big-endian de dumps de memória, logs CAN ou rastros de rede comparando os campos de sinal, expoente e mantissa.
Perguntas frequentes
Posso codificar Infinity e NaN?
Sim. Envie Infinity, -Infinity ou NaN como números ou strings escritas. Eles mapeiam para os padrões padrão de expoente todos uns com mantissa zero ou diferente de zero.
Qual é o padrão de bits do número 1 em dupla precisão?
A palavra hexadecimal é 3FF0000000000000. O bit de sinal é 0, o expoente é 01111111111, que vale 1023, e os 52 bits da mantissa são zero. O expoente real é 0, então o valor é exatamente um.
Por que o expoente é guardado com um deslocamento de 1023?
Para que os 11 bits representem potências de dois positivas e negativas como um único número sem sinal. Em um número normal, subtraia 1023 do expoente guardado para obter o expoente real.
Como aparece um número subnormal nos bits?
O expoente fica todo em zeros e a mantissa é diferente de zero. Os subnormais preenchem o espaço entre o zero e o menor número normal, e a ferramenta os rotula para não serem confundidos com um zero com sinal.
A ferramenta também mostra a precisão simples de 32 bits?
Não. Ela sempre trabalha com dupla precisão de 64 bits, então todo resultado tem a mesma largura: 16 dígitos hexadecimais e 64 dígitos binários. Para precisão simples, use outro conversor.
Ferramentas relacionadas
Para desenvolvedores — acesso via API
Tudo nesta página está disponível via API. Esta seção é para equipes que querem integrar a ferramenta aos próprios sistemas; quem não precisa disso pode simplesmente usar a ferramenta acima.
Endpoint
Autenticação por token Bearer. Um único POST coloca a tarefa na fila; o resultado chega por webhook ou link assinado.
Chame do seu código
curl -X POST https://api.kit.forhosting.com/dev/ieee754-double-bits \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"value":1}'const res = await fetch("https://api.kit.forhosting.com/dev/ieee754-double-bits", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"value": 1
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev/ieee754-double-bits",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"value": 1
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/ieee754-double-bits", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"value":1}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"value":1}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/ieee754-double-bits", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Exemplo de requisição
{
"value": 1
}Exemplo de resposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.ieee754_double_bits",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}A API é assíncrona: cada chamada devolve um task_id na hora. Se preferir polling, consulte o status a até 1 requisição por segundo.
Preço
Preço publicado, sem tokens nem créditos escondidos. Tarefa que falha não é cobrada.
Erros
| HTTP | Código | O que significa |
|---|---|---|
401 | unauthorized | Token ausente ou inválido. Confira o header Authorization. |
402 | insufficient_balance | Saldo insuficiente para esta tarefa. Faça uma recarga e tente de novo. |
404 | unknown_type | Esse tipo de tarefa não existe. Confira o campo type no catálogo. |
429 | rate_limited | Muitas requisições em pouco tempo. Espere um instante e tente de novo. |
Notas técnicas
Um conversor de float de dupla precisão para bits mostra o padrão exato de sessenta e quatro bits IEEE 754 que um computador usa para um número em ponto flutuante. Texto não numérico é rejeitado com invalid_input em vez de ser coagido em silêncio. O caminho é aritmética pura de Worker via DataView—sem rede, sem sementes aleatórias, sem dependência de relógio—assim o executor gratuito do navegador e a API pré-paga devolvem o mesmo JSON sempre para a mesma entrada ao preço base publicado US$ 0,002 por chamada bem-sucedida.
O que o IEEE-754 binary64 armazena: sinal, expoente e mantissa
IEEE-754 binary64 é o formato de intercâmbio que quase toda CPU, GPU e runtime de linguagem moderna usa para aritmética em ponto flutuante de dupla precisão.
Contrato de entrada, forma da resposta e leitura dos campos
Valores especiais Infinity, Infinity negativo e NaN são aceitos como números ou como strings escritas para que você inspecione os padrões de bits canônicos sem inventar flags fora de banda. Exemplo: value igual a um produz hex que começa com três-F-F-zero… e binário que começa com zero seguido de onze uns e cinquenta e dois bits de mantissa zero, category normal, expoente enviesado mil vinte e três, expoente sem viés zero. Envie um corpo JSON com um campo obrigatório chamado value: um número em ponto flutuante de dupla precisão. O campo pode chegar como número JSON ou como string numérica; os alias number, n e decimal são aceitos. Campos ausentes, strings vazias, booleanos, objetos e texto não numérico falham com invalid_input nomeando o campo e não são cobrados. Em caso de sucesso o corpo ecoa o valor publicado (NaN e infinitos como strings porque JSON não os carrega como números), is_neg_zero quando Object.is detecta zero negativo, format binary64, bits sessenta e quatro, hex como dezesseis dígitos maiúsculos sem prefixo, hex_prefixed com zero-x inicial, binary como string de sessenta e quatro caracteres de zeros e uns, sign_bit, exponent_bits, mantissa_bits, sign como mais ou menos um, biased_exponent como inteiro de zero a dois mil quarenta e sete, unbiased_exponent quando definido em casos normais e subnormais, category como uma de normal, subnormal, pos_zero, neg_zero, pos_infinity, neg_infinity ou nan, e exponent_bias sempre mil vinte e três. Combine a resposta com seus próprios visualizadores de dump se precisar de grupos de nibble espaçados; este endpoint devolve strings hex e binárias densas prontas para testes de igualdade.
Onde uma API de float de dupla precisão para bits agrega valor
Educadores e plataformas de exame precisam de um oráculo determinístico que mostre aos alunos a divisão sinal-expoente-mantissa em tarefas de IEEE-754 em vez de um printf opaco só em hex. Como a implementação é pure parse nível A, cada chamada bem-sucedida custa o preço base publicado US$ 0,002 sem tokens de modelo e sem rede de saída. Mantenha as requisições em um único número, fixe as strings hex e de campos nos testes, e você obtém layouts binary64 reproduzíveis para notas de firmware, plugins LMS e workers na borda sem uma biblioteca IEEE local própria.
Casos de integração
Ouro de serializadores e testes unitários
Fixe codificações IEEE-754 esperadas para constantes (1.0, -3.5, pi) na CI para o intercâmbio de float multiplataforma nunca derivar em silêncio.
Checagens de sala de aula IEEE-754
Mostre aos alunos o layout exato de bits 1+11+52 em tarefas de dupla precisão sem contar à mão os campos binários.
Perguntas técnicas
Como converto um float de dupla precisão em bits IEEE-754?
Envie um corpo JSON com value igual ao seu número decimal. A API devolve hex, binary, sign_bit, exponent_bits, mantissa_bits e category da codificação binary64.
É só para doubles de sessenta e quatro bits?
Sim. Esta capacidade sempre codifica IEEE-754 binary64 (1 bit de sinal + 11 de expoente + 52 de mantissa). Não muda para binary32 de precisão simples.
Que erro recebo com entrada não numérica?
A tarefa falha com invalid_input e uma mensagem que nomeia o campo. Entrada inválida não é cobrada.
Quanto custa o conversor de float de dupla precisão para bits?
A ferramenta do navegador é grátis. Requisições API usam saldo KIT pré-pago a US$ 0,002 por chamada bem-sucedida; entrada inválida não é cobrada.