Omni Calculator logo

Calculadora de Ponto Flutuante

Created by Rijk de Wet
Reviewed by Steven Wooding
Translated by Luna Maldonado Fontes and João Rafael Lucio dos Santos, PhD
Based on research by
Institute of Electrical and Electronics Engineers IEEE Standard for Floating-Point Arithmetic; IEEE Std 754-2019 (Revision of IEEE 754-2008); 2019See 1 more source
Institute of Electrical and Electronics Engineers IEEE Standard for Floating-Point Arithmetic; IEEE Std 754-2008; 2008
Last updated: Jan 18, 2024


A calculadora de ponto flutuante da Omni está aqui para ajudar você a entender o padrão IEEE754. Ela atua como um conversor para números de ponto flutuante. Ela converte números flutuantes de 32 bits e 64 bits de representações binárias para números decimais reais e vice-versa.

💡 Você quer converter números binários para o sistema decimal? Talvez tenha interesse no conversor binário 🇺🇸 da Omni!

Como usar a calculadora de ponto flutuante

Antes de entrarmos nos bits e bytes dos formatos de números float32 e float64, vamos aprender como funciona a calculadora de ponto flutuante. Basta que você siga estes passos simples:

  1. Se você quiser converter a codificação binária de um número de ponto flutuante para o número decimal que ele representa, selecione ponto flutuante para número na parte superior da calculadora. Em seguida:

    • Selecione a precisão usada. Isso determina como sua representação binária será interpretada.

    • Digite os dígitos binários do número de ponto flutuante. Você pode inserir o sinal, o expoente e a fração separadamente, ou pode inserir toda a cadeia de bits de uma só vez. Selecione sua preferência no menu suspenso método de entrada de bits.

    • O valor armazenado em seu float será mostrado na parte inferior da calculadora.

  2. Se você quiser converter um valor em sua representação de ponto flutuante, selecione número para ponto flutuante na parte superior da calculadora. Em seguida:

    • Digite o número no próximo campo.

    • As representações binárias e hexadecimais do ponto flutuante IEEE754 de precisão simples e dupla serão mostradas abaixo.

    • A calculadora de ponto flutuante também mostrará a você o valor real armazenado devido à perda de precisão inerente ao formato de ponto flutuante. O erro devido a essa perda de precisão também será relatado.

O que é um número de ponto flutuante IEEE754?

Na computação, um número de ponto flutuante é um formato de dados usado para armazenar números fracionários em uma máquina digital. Um número de ponto flutuante é representado por uma série de bits (1 e 0). Os computadores realizam operações matemáticas usando esses bits, reproduzindo operações que fazemos com números decimais. Quando um ser humano deseja ler o número de ponto flutuante, uma fórmula complexa reconstrói os bits no sistema decimal.

O padrão IEEE754 (estabelecido em 1985 pelo Instituto de Engenheiros Elétricos e Eletrônicos) padronizou o formato de ponto flutuante e também definiu como o formato pode ser operado para executar cálculos matemáticos e outras tarefas. Ele foi amplamente adotado por projetistas de hardware e software e se tornou o padrão para representar números de ponto flutuante em computadores. Quando alguém menciona “números de ponto flutuante” no contexto da computação, geralmente se refere ao formato de dados IEEE754.

💡 O desempenho (ou seja, a velocidade) de um computador pode ser medido pelo número de operações de ponto flutuante que ele pode fazer por segundo. Essa métrica é chamada de FLOPS e é crucial nos campos da computação científica.

O formato de ponto flutuante IEEE754 mais conhecido (precisão simples, ou “32 bits”) é usado em quase todos os aplicativos de computadores modernos. O formato é altamente flexível: o float32 pode codificar números tão pequenos quanto 1,4×10-45 e tão grandes quanto 3,4×1038 (positivos e negativos).

Além do formato de precisão simples, o padrão IEEE754 também codifica a precisão dupla (“64 bits” ou float64), que pode armazenar números de 5×10-324 a 1,7×10308. Os formatos IEEE754 menos usados incluem:

  • Meia precisão (“16 bits”);
  • Precisão quádrupla (“128 bits”); e
  • Precisão óctupla (“256-bit”).

💡 Tecnicamente, embora o IEEE754 defina apenas esses formatos, qualquer precisão arbitrária é possível. Muitos computadores antigos usavam números de ponto flutuante de 24 bits!

No entanto, um número de ponto flutuante não é simplesmente um número conversor integrado ao sistema de números binários; ele é muito mais complicado do que isso! Vamos aprender como funciona o padrão de ponto flutuante IEEE754.

Como os números reais são armazenados com a representação de ponto flutuante?

Qualquer representação binária de ponto flutuante consiste em três segmentos de bits: sinal, expoente e fração.

  • O sinal (S) indica se o número é positivo ou negativo;
  • O exponente (E) eleva 2 a alguma potência para escalonar o número; e
  • A fração (F) determina os dígitos exatos do número.

Os comprimentos dos segmentos e a fórmula exata aplicada a S, E e F para recriar o número dependem da precisão do formato.

Quando armazenados na memória, SS, EE e FF são colocados de ponta a ponta para criar a representação binária completa do número de ponto flutuante. Na memória do computador, ele pode ter a seguinte aparência:

Os bits de um número de ponto flutuante armazenados na memória.

Esses bits são o que o computador manipula quando a aritmética e outras operações são realizadas. O computador nunca vê um número como seus dígitos decimais, ele só vê e trabalha com esses bits.

💡 A escolha da precisão depende do que o aplicativo exige. Mais precisão significa mais bits e maior exatidão, mas também maior espaço de armazenamento e maior tempo de computação.

Vejamos em mais detalhes os dois formatos de ponto flutuante mais comuns: float32 e float64.

O formato de precisão única de 32 bits do ponto flutuante

O float32 é o formato IEEE754 mais comumente usado. Conforme sugerido pelo termo “32-bit float”, sua representação binária subjacente tem 32 bits de comprimento. Eles são segmentados da seguinte forma:

  • 1 bit para o sinal (SS);
  • 8 bits para o expoente (EE); e
  • 23 bits para a fração (FF).

Quando armazenados na memória, os bits têm a seguinte aparência:

Os bits de um número de ponto flutuante de 32 bits.

Podemos reescrevê-lo como uma cadeia de caracteres (string) binária:

b1 b2 b3 ... b30 b31 b32\small b_1\ b_2\ b_3 \ ...\ b_{30}\ b_{31}\ b_{32}

O valor real que esse float de 32 bits armazena pode ser calculado da seguinte forma:

(1)b1 ⁣× ⁣2(b2 ... b9)2127 ⁣× ⁣(1.b10...b32)2\small (-1)^{b_1} \!\times\! 2^{(b_2\ ...\ b_9)_2-127} \!\times\! (1.b_{10}...b_{32})_2

onde:

  • 127127 é chamado de desvio de expoente e é inerente ao formato de precisão simples;
  • x2x_2 significa que xx deve ser interpretado como se estivesse na base 2 ou binária; e
  • (1.b10...b32)2(1.b_{10}...b_{32})_2 significa que você deve pegar os bits binários b10b_{10} a b32b_{32} e usá-los como a parte fracionária de 11 para formar uma fração binária. Consulte nosso conversor de frações binárias 🇺🇸 para obter ajuda sobre esse tópico.

Você pode reescrever melhor a fórmula usando SS, EE e FF, ou seja:

(1)S×2E127×(1.F)2\small (-1)^S \times 2^{E-127} \times (1.F)_2

onde:

  • S=b1S = b_1;
  • E=(b2 ... b9)2E = (b_2\ ...\ b_9)_2; e
  • F=(b10 ... b32)2F = (b_{10}\ ...\ b_{32})_2.

Para permitir que os formatos de ponto flutuante armazenem números realmente pequenos com alta precisão, E=0E=0 e F>0F>0 devem ser aplicados a uma outra fórmula. Para o float32, essa fórmula é:

(1)S×2126×(0.F)2\small (-1)^S \times 2^{-126} \times (0.F)_2

Os números criados por essa fórmula são chamados de “números subnormais”, enquanto os “números normais” são criados usando a fórmula anterior.

outros casos especiais, codificados por valores específicos para EE e FF:

EE

FF

Valor

00

00

±0\pm 0

00

>0>0

(1)S×2126×(0.F)2\small (-1)^S \times 2^{-126} \times (0.F)_2

0<E<2550 < E<255

Qualquer um

(1)S×2E127×(1.F)2\small (-1)^S \times 2^{E-127} \times (1.F)_2

255255

00

±\pm \infty

255255

>0>0

NaN\text{NaN}

NaN\text{NaN} significa “não é um número” (Not a Number em inglês), que é retornado quando você divide por zero ou realiza cálculos impossíveis usando o infinito. Nos casos de ±0\pm 0 e ±\pm \infty, o bit de sinal determina se o número é positivo ou negativo. E sim, o zero negativo existe!

Um exemplo

Vamos converter a representação binária de ponto flutuante 01000001110111100000000000000000 para o número real que ela representa.

  1. Primeiro, vamos segmentá-lo em SS, EE e FF:

    • S=02=0S = 0_2 = 0

    • E=100000112=131E = 10000011_2 = 131

    • F=101111000000000000000002F = 10111100000000000000000_2

  2. Como 0<E<2550<E<255, usamos a fórmula do número normal:

    (1)S×2E127×(1.F)2(-1)^S \times 2^{E-127} \times (1.F)_2

    • (1)S=1(-1)^S = 1 (portanto, o número é positivo!)

    • 2E127=24=162^{E-127} = 2^{4} = 16

    • (1.F)2=1.1011112=1,734375(1.F)_2 = 1.101111_2 = 1{,}734375

  3. Combine os três números através de uma multiplicação:

    1161,734375=27,751 \cdot 16 \cdot 1{,}734375 = \textbf{27,75}

Quer ver com seus próprios olhos? Experimente esse valor em nossa calculadora de ponto flutuante para que você a veja em ação!

Observe que 01000001110111100000000000000000201000001110111100000000000000000_2 convertido diretamente de binário para decimal não é 27,7527{,}75, mas 1. ⁣105. ⁣068. ⁣0321.\!105.\!068.\!032. Uma grande diferença, você não acha?

💡 A fórmula dos números de ponto flutuante pode ser vista como uma forma de notação científica, onde utilizamos potências de base de 2. Podemos reescrever o exemplo acima como 1,734375×241{,}734375 \times 2^{4}. Consulte nossa calculadora de notação científica para obter mais informações.

O formato de precisão dupla de 64 bits do ponto flutuante

Os funcionamentos internos do tipo de dados float64 são muito parecidos com os do float32. As principais diferenças entres esses dois floats são:

  • Os comprimentos dos segmentos de expoente e fração da representação binária: em floats de 64 bits, EE ocupa 11 bits e FF ocupa 52.
  • O desvio de expoente: em floats de 64 bits, é 1023 (enquanto em floats de 32 bits, é 127).

As fórmulas para a reconstrução de pontos flutuantes normais e subnormais de 64 bits são, portanto, respectivamente:

(1)S×2E1023×(1.F)2\small (-1)^S \times 2^{E-1023} \times (1.F)_2

e

(1)S×21022×(0.F)2\small (-1)^S \times 2^{-1022} \times (0.F)_2 \\

Devido aos bits adicionais de expoente e fração em comparação com o float32, o float64 pode armazenar números muito maiores e com precisão muito maior.

💡 Todos os formatos de ponto flutuante IEEE754 seguem esse padrão, sendo que as maiores diferenças são a polarização e os comprimentos dos segmentos.

Como converter um número em ponto flutuante?

Para converter um número decimal em uma representação de ponto flutuante, siga estas etapas:

  1. Converta o número inteiro para binário e, em seguida, normalize-o, ou seja, escreva-o em notação científica usando a base 2.
  2. Trunque a fração após o ponto decimal para o comprimento de fração permitido.
  3. Extraia o sinal, o expoente e os segmentos da fração.

Consulte o padrão IEEE754 para obter instruções mais detalhadas.

Um exemplo

Vamos converter 27,7527{,}75 de volta à sua representação de ponto flutuante.

  1. Nossa parte inteira é 2727, que em binário é 11011211011_2. Nossa parte fracionária é 0,750{,}75. Vamos convertê-la em uma fração binária:

    • 0,752=1,50=1+0,50{,}75 \cdot 2 = 1{,}50 = \textbf{1} + 0{,}5

    • 0,52=1,00=1+00{,}5 \cdot 2 = 1{,}00 = \textbf{1} + 0

    Portanto, 0,75=0,1120{,}75 = 0{,}11_2, e 27,75=11011,11227{,}75 = 11011{,}11_2. Para normalizá-lo, nós o reescrevemos como:

27,75= 11011,112= (1,101111×24)2\small \begin{aligned} \qquad\quad& 27{,}75 \\ =&\ 11011{,}11_2 \\ =&\ (1{,}\textcolor{red}{101111} \times 2^{\textcolor{blue}{4}})_2 \\ \end{aligned}
  1. Os dígitos após o ponto decimal já têm um tamanho adequado. Para float32, estaríamos limitados a 23 bits, mas temos apenas cinco.

A partir da reescrita normalizada, podemos deduzir que:

  • S=0S = 0, já que o número é positivo;
  • E=4+127=100000112E = \textcolor{blue}{4}+127 = 10000011_2 (adicionamos 127127 porque E127E-127 deve ser 4\textcolor{blue}{4}); e
  • F=10111100000000000000000F = \textcolor{red}{101111}00000000000000000 (os zeros são preenchidos à direita porque estamos lidando com dígitos fracionários e não com um número inteiro).

Portanto, nossa representação de ponto flutuante é: 010000011101111000000000000000000\textcolor{blue}{10000011}\textcolor{red}{101111}00000000000000000.

Você pode verificar esse resultado com a calculadora de ponto flutuante da Omni!

Precisão do ponto flutuante

Os números de ponto flutuante não podem representar todos os números possíveis com precisão total. Isso faz sentido intuitivamente para números suficientemente grandes e para números com um número infinito de casas decimais, como o pi (π\pi) e o número de Euler (ee). Mas você sabia que os computadores não conseguem armazenar um valor tão simples como 0,10{,}1 com 100% de precisão? Vejamos em detalhes essa afirmação!

Quando você pede a um computador para armazenar 0,10{,}1 como um float32, ele armazenará essa cadeia de caracteres binária:

00111101110011001100110011001101

Se você converter isso de volta para decimal com as fórmulas de ponto flutuante que aprendemos acima, obteremos o seguinte:

  • S=0S = 0
  • E=011110112=123E = 01111011_2 = 123
  • F=100110011001100110011012F = 10011001100110011001101_2
 (1)S×2E127×(1,F)2= (1)0×2123127×(1,1001...1)2= 1×0,0625×1,6000000238418579101= 0,10000000149011611938477\small \begin{aligned} &\ (-1)^S \times 2^{E-127} \times (1{,}F)_2 \\ =&\ (-1)^0 \times 2^{123-127} \times (1{,}1001...1)_2\\ =&\ 1 \times 0{,}0625 \\ &\quad \times 1{,}6000000238418579101 \\ =&\ 0{,}10000000149011611938477 \end{aligned}

Isso é um pouco mais do que 0,10{,}1! O erro (a distância entre o valor de ponto flutuante armazenado e o valor “correto” de 0,10{,}1) é 1,49×1091{,}49 \times 10^{-9}.

Um meme sobre problemas de precisão de ponto flutuante.

Tentemos corrigir esse erro e fazer a menor alteração possível. Nosso número armazenado é um pouco grande demais, então vamos alterar o último bit de 11 para 00 para tornar nosso float um pouco menor. Agora estamos convertendo:

00111101110011001100110011001100

  • S=0S = 0
  • E=011110112=123E = 01111011_2 = 123
  • F=100110011001100110011002F = 10011001100110011001100_2
 (1)S×2E127×(1,F)2= (1)0×2123127×(1,1001...0)2= 1×0,0625×1,5999999046325683594= 0,09999999403953552246094\small \begin{aligned} &\ (-1)^S \times 2^{E-127} \times (1{,}F)_2 \\ =&\ (-1)^0 \times 2^{123-127} \times (1{,}1001...0)_2\\ =&\ 1 \times 0{,}0625 \\ &\quad \times 1{,}5999999046325683594 \\ =&\ 0{,}09999999403953552246094 \end{aligned}

E novamente passamos longe de 0,10{,}1! Desta vez, o erro é um pouco maior (5,96×1095{,}96\times 10^{-9}). A primeira cadeia de caracteres binária que terminou em 1 estava ainda mais correta do que esta!

Você pode pensar: “e se usássemos mais bits?” Bem, se você fizesse o mesmo com o formato float64, encontraria o mesmo problema, embora menos grave. 0,10{,}1 convertido para um ponto flutuante de 64 bits e de volta para decimal é 0,1000000000000000060{,}100000000000000006, e o erro aqui é 5,55×10185{,}55 \times 10^{-18}. Essa é a maior precisão do float64 em ação, mas o erro ainda não é 00, a conversão ainda não é sem perdas.

Infelizmente, essa é a desvantagem do onipresente formato de ponto flutuante: não é 100% preciso. Pequenos fragmentos de informação são perdidos e podem causar estragos se não forem levados em conta. Os únicos números que podem ser armazenados perfeitamente como float sem nenhuma perda são potências de 2 escalonadas por inteiros porque é assim que o formato armazena números. Todos os outros números são simplesmente aproximados quando armazenados como um número de ponto flutuante. Ainda assim, isso é o melhor que temos.

💡 Algumas operações são mais resistentes à perda de precisão. Experimente nossa calculadora de número de condição para ver o quanto uma perda de precisão afetará as operações de matriz.

FAQ

Por que usamos números de ponto flutuante?

O padrão IEEE754 de ponto flutuante permite o armazenamento e processamento eficientes de números em computadores.

  • Do ponto de vista do hardware, muitas simplificações das operações de ponto flutuante podem ser feitas para acelerar significativamente a aritmética, graças às especificações do padrão IEEE754.

  • Para o software, os pontos flutuantes são muito precisos e normalmente perdem alguns milionésimos (se não menos) por operação, o que permite aplicações científicas e de engenharia de alta precisão.

Qual é a representação em ponto flutuante de 12,25?

A representação em ponto flutuante de 12,25 é 01000001010001000000000000000000. Seu sinal é 0, seu expoente é 100000102 = 130 e sua fração é 100010...0. Reconstruído em decimal, obtemos:

(-1)0 × 2(130-127) × (1,10001)2
= 1 × 23 × 1,53125
= 12,25

Rijk de Wet
I want to convert
floating-point to number
Precision
Single-precision (32 bits)
Bit input method
Separately
Input the sign, exponent, and fraction, all in binary.
Sign
S = 02 = 0
Exponent
E = 000000002 = 0
Fraction
F = 000000000000000000000002 = 0
Single-precision floating-point representations:
Binary: 000000000000000000000000000000002
Hexadecimal: 00000000H
Result
+0
E=0 and F=0 is a special case for ±0. Because S=0, the final result is +0.
Check out 32 similar tech and electronics calculators 💻
3D printing costAmdahl's lawBattery capacity… 29 more
People also viewed…

CBM for shipping

A calculadora da CBM para entregas da Omni determina o volume e o peso de sua remessa.

Chilled drink

Com a calculadora de drinks gelados, você pode verificar rapidamente quanto tempo precisa manter sua bebida na geladeira ou em outro local frio para que ela fique na temperatura ideal. Você pode acompanhar como a temperatura muda com o tempo com o nosso gráfico interativo.

Chord transposer

The chord transposer can move your chords from one key to another or move them up or down by intervals.

Circumference

Use essa calculadora de circunferência gratuita da Omni para encontrar a área, o perímetro e o diâmetro de um círculo.