Vírgula flutuante e IEEE 754

Guardar o inteiro 26 e interpretá-lo em unidades de $1/8$ dá $26/8=3{,}25$. Nenhum bit da palavra assinala a vírgula, pois essa escala faz parte do acordo entre o circuito e o programa; na vírgula fixa, o passo é constante, enquanto na vírgula flutuante um expoente guardado com o significando altera a escala e o espaçamento entre valores.

Convenção Qm.n

Usamos $Qm.n$ com $m$ bits para a parte inteira incluindo o sinal e $n$ bits fracionários; a largura total é $N=m+n$. O inteiro $X$ está em complemento para dois e representa

$$x=X\,2^{-n}.$$

O intervalo é $[-2^{m-1},\,2^{m-1}-2^{-n}]$ e a resolução é $2^{-n}$. Em $Q4.4$, os 8 bits representam de $-8$ a $7{,}9375$, em passos de $0{,}0625$.

Para codificar $-2{,}75$ em $Q4.4$, calcula $X=-2{,}75\times16=-44$. Em 8 bits, $256-44=212=\mathrm{D4}_{16}$. Para descodificar D4, lê primeiro $-44$ em complemento para dois e só depois divide por 16.

Escolher um formato

Queremos medir valores entre $-20$ e $+20$ com passo não superior a $0{,}01$. Precisamos de $2^{-n}\le0{,}01$: $n=7$ dá $1/128\approx0{,}0078125$. Para o intervalo, $m=5$ só chega a menos de 16, enquanto $m=6$ chega a menos de 32, portanto $Q6.7$, com 13 bits, satisfaz ambas as condições.

Se a palavra disponível só tiver 12 bits, não podemos manter essas duas escolhas. Temos de reduzir o intervalo, aceitar um passo maior ou aumentar a largura, porque a precisão e o intervalo competem pelos bits.

Um valor não múltiplo da resolução exige arredondamento ou truncatura. Em $Q4.4$, $0{,}1\times16=1{,}6$: arredondar para o inteiro mais próximo dá $X=2$ e valor $0{,}125$, enquanto truncar para zero dá $X=1$ e valor $0{,}0625$. Indica a política usada.

Adição e mudança de escala

Com a mesma escala, somamos os inteiros: $x+y=(X+Y)2^{-n}$. Em $Q4.4$, $1{,}5$ é 24 e $-0{,}75$ é $-12$, por isso a soma 12 representa $0{,}75$; o teste de overflow é o da palavra inteira com sinal.

Se as escalas diferirem, alinha-as primeiro. Converter de $Q4.4$ para $Q4.6$ exige multiplicar o código por $2^2$, acrescentando dois bits fracionários. Converter no sentido inverso perde bits e pode exigir arredondamento. Um deslocamento à direita aritmético de negativos arredonda para baixo; não equivale sempre a truncar para zero.

Por exemplo, soma 1,5 guardado com quatro bits fracionários a 0,25 guardado com seis. Os códigos são 24 e 16; na escala de seis bits, o primeiro passa a $24\times4=96$. Agora $96+16=112$ representa $112/64=1{,}75$, enquanto somar diretamente 24+16 misturaria unidades diferentes.

Multiplicação e divisão

Se $x=X2^{-n}$ e $y=Y2^{-n}$, o produto inteiro $XY$ tem escala $2^{-2n}$. Para voltar à escala inicial, calcula $XY/2^n$ com largura suficiente para o produto intermédio.

Em $Q4.4$, $1{,}5\times(-0{,}75)$ usa $24\times(-12)=-288$. Dividindo por 16 obtemos $-18$, que representa $-1{,}125$. O produto $-288$ não cabe em 8 bits, embora o resultado final caiba. Fazer a multiplicação já em 8 bits destruiria o resultado.

Para obter $x/y$ na escala $2^{-n}$, com $y\ne0$, calcula com numerador alargado e arredondamento definido

$$Z=\frac{X\,2^n}{Y},\quad y\ne0,$$

como em $1{,}5/0{,}75$, que dá $(24\times16)/12=32$, ou seja, 2.

Com escalas $n_1,n_2$ nas entradas e $n_3$ no resultado, o produto requer um deslocamento de $n_1+n_2-n_3$ posições à direita, se esse valor for não negativo. Separar a escala da largura evita confundir overflow com perda de precisão.

Campos e valores

O sinal $s$ vale 0 para positivo e 1 para negativo. A tabela indica o número de bits de cada campo e o bias do formato.

Formato	Sinal $s$	Expoente $E$	Fração $F$	Bias
binary32	1	8	23	127
binary64	1	11	52	1023
bfloat16	1	8	7	127

Aqui $E$ e $F$ são os inteiros sem sinal lidos dos respetivos campos. $E_{\max}$ é o expoente com todos os bits a 1: 255 em binary32. O bias é a constante subtraída a $E$ para obter o expoente real. $p$ é o número de bits da fração.

Se $0<E<E_{\max}$, o número é normal, com

$$x=(-1)^s\left(1+\frac{F}{2^p}\right)2^{E-\mathrm{bias}},$$

onde o 1 antes da vírgula é implícito; assim binary32 tem 24 bits de precisão no significando dos normais.

Se $E=0$, não há esse 1, com

$$x=(-1)^s\frac{F}{2^p}2^{1-\mathrm{bias}}.$$

Com $F\ne0$ obtemos um subnormal. Com $F=0$ obtemos $+0$ ou $-0$.

Se todos os bits do expoente forem 1, o valor depende só da fração: $F=0$ significa infinito e $F\ne0$ significa NaN, not a number. NaN não é um número muito grande; é o código para resultados sem valor numérico.

Binary32 e binary64 são formatos IEEE 754. Bfloat16 usa a disposição indicada na tabela; não se deve inferir que qualquer operação ou conversão de bfloat16 tenha as mesmas regras de um ambiente IEEE 754 completo. Nos exemplos de arredondamento abaixo usamos explicitamente o modo mais próximo, com empates para par.

Codificar um valor

Codifica $-13{,}25$ em binary32. O módulo é $1101{,}01_2=1{,}10101_2\times2^3$, portanto $s=1$, $E=3+127=130=10000010_2$ e a fração é 10101 seguida de 18 zeros:

1 | 10000010 | 10101000000000000000000

Agrupar em grupos de quatro bits dá 0xC1540000. Para descodificar, reconstrói $-(1+1/2+1/8+1/32)\times8=-13{,}25$. Não interpretes a palavra completa em complemento para dois.

Limites e espaçamento

Em binary32, o menor normal positivo é $2^{-126}$ e o menor subnormal positivo é $2^{-149}$. O maior finito é $(2-2^{-23})2^{127}$. Os subnormais mantêm passos de $2^{-149}$ perto de zero, com menos bits significativos à medida que o valor diminui.

No intervalo $[2^e,2^{e+1})$, os normais binary32 têm espaçamento $2^{e-23}$. Entre 1 e 2 é $2^{-23}$; entre 2 e 4 é $2^{-22}$. Em bfloat16, o menor representável maior que 2 é $2+2^{-6}$, porque o expoente tem a mesma largura de binary32 mas a precisão é muito menor.

Somar e subtrair

Para somar $5{,}5+1{,}25$, escreve $1{,}011_2\times2^2$ e $1{,}01_2\times2^0$. Os bits só podem ser somados por coluna quando têm os mesmos pesos, por isso conserva o expoente 2 e desloca o segundo significando duas posições à direita:

   1,0110 × 2²       5,5
 + 0,0101 × 2²       1,25
   ──────────
   1,1011 × 2²       6,75

O zero acrescentado ao primeiro significando só completa a coluna. O resultado já está normalizado, pois o significando está entre 1 e 2.

Subtrair usa o mesmo alinhamento: $5{,}5-5{,}25$ dá $(1{,}011-1{,}0101)\times2^2=0{,}0001\times2^2=1\times2^{-2}=0{,}25$. Depois de uma quase anulação, pode ser preciso normalizar deslocando para a esquerda.

No formato finito, conserva bits adicionais durante a conta e arredonda no fim. O modo usual é o mais próximo, com empates para o significando cujo último bit conservado é par. Truncar sempre não implementa esta regra.

Um modelo pequeno com três bits de fração ajuda a ver um empate. Entre 1 e 2, os números avançam de 1/8 em 1/8; o valor $1+1/16=1{,}0001_2$ fica a meio de 1,000 e 1,001, por isso escolhemos 1,000, cujo último bit é 0. Já $1+3/16=1{,}0011_2$ fica a meio de 1,001 e 1,010, por isso escolhemos 1,010. Empate para par pode arredondar para cima ou para baixo; este modelo serve apenas para explicar a regra, pois binary32 conserva 23 bits de fração.

Multiplicar e perder precisão

Na multiplicação, trata cada campo em separado: XOR dos sinais, soma dos expoentes reais e produto dos significandos. Para $1{,}5\times2{,}5$, os significandos dão $(1{,}1\times1{,}01)=1{,}111$, com expoente 1, ou seja, $3{,}75$. Se o produto dos significandos atingir 2, divide-o por 2 e aumenta o expoente em 1.

Overflow pode produzir infinito; resultados demasiado pequenos podem tornar-se subnormais ou zero. Reduzir a precisão também exige arredondar, mesmo dentro do intervalo: $1{,}1$ não tem representação binária finita, por isso binary64 guarda-o arredondado a 52 bits e a passagem a binary32 arredonda de novo a 23 bits. No exercício de bfloat16 do volume 1, a ausência de subnormais é uma hipótese local desse enunciado, não uma propriedade geral do formato.

A adição não é associativa em geral. Em binary32, $2^{24}+1$ arredonda para $2^{24}$, pois o passo é 2 e o empate conserva o último bit par. Assim $(2^{24}+1)-2^{24}=0$, mas $2^{24}+(1-2^{24})=1$.

A visualização separa sinal, expoente e fração e aplica as regras de binary32, sem efetuar uma nova operação aritmética entre floats. Os bits são exatos; a escrita decimal de valores muito pequenos ou grandes é uma aproximação. Para NaN e infinito, a fórmula dos números finitos não se aplica.