0.1 + 0.2 == 0.3 = False???

Bom, ultimamente estive trabalhando em um joguinho aqui que utiliza networking no GML, e acabei sendo forçado a aprender a manipular os buffers, e isso me fez ter um interesse ainda maior por programação e acabei seguindo alguns canais sobre programação em outras linguagens.

Mas hoje, um canal que curto muito (canal do Fabio Akita) postou hoje sobre algumas coisas tecnicas sobre processadores e como eles trabalham com os dados.

E nesse vídeo ele abordou um assunto que me deixou curioso...

Bom, todos sabemos, que 0,1 + 0,2 é igual a 0,3 certo? Porem se voce tentar programar isso em python, ele vai retornar como FALSE...
Fiquei bem curioso com isso, e resolvi testar no GML, por ser uma engine de jogos acreditei que ele "driblaria" esse erro, mas ele também retorna false.

Se liguem.


Porem se voce calcular outro valor por exemplo, 0,2 + 0,2 == 0,4, ele retorna como TRUE.


Pode testar ai se você quiser hehe

Código:


///Codigo simples para testes
var check = 0.1 + 0.2 == 0.3;

   if (check)
      _return = "true";
   else
      _return = "false";
   

show_debug_message("0.1 + 0.2 == 0.3 is :"+string(_return));



Fiquei bem surpreso com isso, e ativa um sinal de atenção pra quem trabalha com dados e etc. Esse tipo de verificação faz o sistema verificar se o valor é EXATAMENTE igual 0,3 mas como esse resultado deixa uma "sujeirinha" nos valores flutuantes, coisas assim podem acontecer...

As vezes você pode programar certo, mas o resultado sai errado, agora você sabe o que pode ser.

Bem, achei bem interessante isso, e (caso esteja deslogado) deixei o video em questão como hyperlinks aqui na mensagem. Caso queira ver sobre algo mais.

e é isso ai...

Por isso que colisões bugam com números quebrados (0.xx), tem partes no manual que fala que algumas funções arredondam para o valor mais próximo...
Agora tudo faz mais sentido, por isso que quando eu tentava programar colisões com WHILE o jogo simplesmente travava, por causa dos números não inteiros o while nunca se resolvia
É bom ver essas coisas e aprender mais.

Uma curiosidade e que testando em javascript o mesmo erro acontece. Porem, percebi que se voce utilizar:

Código:

if(0.1+0.2==0.30000000000000004){ show_message("Igual") } else { show_message("Diferente") }

Ira funcionar, exibindo igual. A diferenca e minima como podemos perceber.

Para quem quiser debugar no console do seu navegador, que ira processar JavaScript:

Código:


console.log(0.1+0.2);


Quanto é 10 / 3 ?
Não conseguimos representar o resultado com um número finito de dígitos. Mas poderíamos aproximá-lo: 3, 3.3, 3.33, 3.333, 3.3333 e assim por diante (depende da precisão desejada), ou, dependendo do critério, até 3.34.
As pessoas costumam usar a base 10 no dia a dia (de 0 a 9 e depois reinicia). Por exemplo, o número 705 é dado por ... + 0*10^3 + 7*10^2 + 0*10 + 5*(10^0) + 0*(10^-1) + ... + 0*(10^-30) + 0*(10^-31) + ...
Obs: "..." significa que foram omitidos alguns (ou infinitos) termos (que valem 0 neste caso) antes ou depois da sequência.
Omitindo-se os termos nulos, percebemos um resultado exato com uma representação finita (ou seja, 3 termos).
Programadores usam vários sistemas, incluindo os sistemas decimal (base 10), hexadecimal (base 16), octal (base 8 ), e principalmente o sistema binário, que é o sistema base do computador.
O computador usar o sistema binário significa que ele precisa representar os números com potências de 2 e não de 10 (como no exemplo que dei acima).
Por exemplo:
8 = ... + 0*(2^4) + 1*(2^3) + 0*(2^2) + ... + 0*(2^-908) + ...
0.25 = ... 0*(2^904) + ... + 1*(2^-4) + 0*(2^-5) + ...
Alguns números não podem ser representados por somas de potências de 2 (com um número finito de termos), assim como 10/3 não pode ser representado por uma soma com um número determinado de termos de potências de 10.
Tente fazer a representação do número 0.2 em binário.
Você vai ver que aparece uma dízima: 0.00110011001100110011...
Concluindo, não é possível representar 0.2 em binário de forma exata. A precisão depende do número de bits que o sistema suporta.
Ao fazer uma operação com um número desse tipo, os resultados são "ligeiramente" arredondados.

Aliás, no exemplo que funciona 0.2+0.2 == 0.4, é como fazermos 10/3 + 10/3 + 10/3 = 10.

Sim da pra se imaginar um monte de aplicação errônea graças a essa falha NPH
Não sei ao certo TRFN mas acho que algumas linguagens conseguem corrigir isso, acho que C faz isso...

Pedro Pedro... você me fez ter o interesse em estudar melhor conversão binária , vou aprender logo antes que eu me matricule e tenha que aprender a força...