Post History

​$\textbf{Introdução}$

​Os números de ponto flutuante são uma parte essencial para o funcionamento de todos os computadores, pois são eles que possuem o papel de representar os números não inteiros nesses sistemas. Por exemplo, são eles que estão trabalhando quando você faz uma operação com um "número com vírgula" na sua calculadora.

​Para responder a essa pergunta, irei me basear no livro Cálculo Numérico: Aspectos Teóricos e Computacionais das autoras Márcia Ruggiero e Vera Lopes, no padrão IEEE 754, que define o funcionamento dos números de ponto flutuante, e também em outras fontes menos relevantes.

$​\textbf{Definição}$

​Um número de ponto flutuante é todo aquele que pode ser representado por:
$$(0,d_1d_2d_3...d_t)\beta^{(e)}(-1)^{(s)} \quad d_i \in [0,\beta-1] \, \land \, d_1 \neq 0$$

​Onde $t$ é o valor máximo da mantissa, ou seja, a quantidade de dígitos que o seu número pode ter;

​$\beta$ é a base do sistema, como binária (2), octal (8), decimal (10), entre outras (com $\beta \geq 2$);

​$e$ é o valor do expoente que eleva a base, ele sempre vai pertencer a um conjunto $[l,h] \subset \mathbb{N}$, onde $l$ é o menor expoente que o sistema pode ter e $h$ é o maior;

​$s$ é um número booleano (0 ou 1) que define se o valor é positivo ou negativo.

​Na norma *IEEE 754* essa definição é dada de uma forma um pouco diferente e mais complexa, sendo ela:

​$$(-1)^{(s)} \cdot \left(1+ \sum_{i=1}^{t}d_{t-i} \cdot \beta^{(-i)}\right) \cdot \beta^{(E-(2^{(u-1)}-1))}$$

​Onde os dígitos $d$ são sempre binários e $(E-(2^{(u)}-1))$ substitui o nosso $e$ utilizando um sistema para definir se a potência é positiva ou negativa chamado de viés (ou bias). $E$ é um valor que está dentro do conjunto $[0,2^{(u)}-1] \subset \mathbb{N}$, e $u$ é 2 elevado à quantidade de bits reservados para o expoente.

​$\textbf{Exemplo}$

​Darei um exemplo usando um ponto flutuante com precisão dupla (64 bits), mostrando-o tanto na definição mais inteligível quanto na dada pelo IEEE 754.

*​Definição inteligível*

​$$(0,d_1d_2d_3...d_{52}) \cdot 2^{(e)} \cdot (-1)^s \quad \forall e \in [-1023,1023] \, , \, s \in \{0,1\}$$

​Isto é, temos reservados 52 bits para a mantissa ($t$), 11 bits para o expoente ($e$), um bit para o sinal da função ($s$) e todos os dígitos são binários ($\beta$).

​*Definição IEEE 754*

​$$(-1)^{(s)} \cdot \left(1+ \sum_{i=1}^{52}d_{52-i} \cdot 2^{(-i)}\right) \cdot \beta^{(E-(2^{(10)}-1))}$$
$$ \quad \forall E \in [0,2047]$$

​Neste caso, $u=11$, que é a quantidade de bits reservados para representar o expoente.

​$\textbf{Mantissa}$

​Com a base dos números de ponto flutuante mais compreendida, podemos partir para algumas de suas característica, a primeira delas é sobre como esses números se comportam em diferentes situações de mantissa. Já sabemos que quando há uma quantidade de dígitos menor ou igual ao limite da mantissa, tudo ocorre como o esperado. Porém, quando esse limite é ultrapassado, ocorre um arredondamento.

​Por exemplo, vamos imaginar dois números de ponto flutuante $f_1$ e $f_2$ que pertencem a um sistema decimal com limite de mantissa $t=2$ e de expoente $e \in [-3,3]$. Se $f_1 = 0,1 \cdot 10^3$ e $f_2 = 0,1 \cdot 10$, ao somá-los, obteremos um $f_3=0,101 \cdot 10^3$, o que é problemático, pois ele estoura o máximo da mantissa. Então, o computador irá entrar em um processo de arredondamento.

​Existem muitos tipos de arredondamento descritos na norma *IEEE 754*, mas focarei neste exemplo no de truncamento, que basicamente transforma em $0$ tudo que passou pelo limite da mantissa. Portanto, teremos que $f_3=0,1 \cdot 10^3$.

​Apesar de ter usado o truncamento, na maior parte das vezes os processadores utilizam um método de arredondamento para o valor mais próximo chamado de bits GRS; é mais fácil encontrar conteúdo sobre isso pesquisando por sticky bit.

​$\textbf{Underflow e Overflow}$

​Underflows e overflows ocorrem quando há uma quebra dos limites do expoente, isto é, o número que você está tentando representar é tão grande ou tão pequeno que o seu sistema de ponto flutuante não consegue representá-lo.

​Quando o número é muito pequeno para o sistema, ocorre o underflow. Nisso, o computador pode usar um bit da mantissa para representar expoentes menores, sacrificando um pouco da precisão do número; se mesmo após isso não for possível representá-lo, o computador só irá considerá-lo como $0$.

​Já quando um número é muito grande para o sistema, ocorre um overflow, que pode ser interpretado pelo computador como um número Inf ou -Inf.

​$\textbf{Considerações finais}$

​Foi muito divertido estudar sobre este tema, pois gosto muito de entender como o computador funciona por debaixo dos panos, ainda mais quando isso envolve matemática. Além disso, gostaria de pedir aos leitores compreensão com possíveis erros que eu possa ter cometido durante a explicação deste tópico, pois sou apenas um estudante de graduação bem entusiasmado.

​Dito isso, espero que esta publicação os tenha ajudado a entender um pouco mais a fundo como os números de ponto flutuante funcionam.