Arredondamento de números em MT4 via NormalizeDouble - página 17

[Sergei Vladimirov]

pavlick_:

Eu escrevi um pequeno código de treinamento (eu estava interessado em me espreitar) que revela o interior do número flutuante.

A saída a f == 0,5 + 1/(2^24). 1/(2^24) é o dígito mais jovem da mantissa em um determinado grau:

O que exatamente você queria ver lá? Os números flutuantes têm um bit por sinal, 8 bits por expoente, e os 23 restantes são mantissa, ou seja, a precisão máxima é de 23 casas decimais em representação binária, ou seja, 7 casas decimais. Para números duplos, há 1 bit por sinal, 11 bits por expoente, os 52 bits restantes são mantissa, a precisão máxima é de 52 casas decimais em representação binária ou 16 casas decimais. Por que existe um código para isso?

[pavlick_]

Sergei Vladimirov:

O que exatamente você queria ver lá? Os números flutuantes têm um bit por sinal, 8 bits por expoente, os 23 restantes são mantissa, ou seja, a precisão máxima de 23 casas decimais em representação binária, ou 7 casas decimais. Para números duplos, há 1 bit por sinal, 11 bits por expoente, os 52 bits restantes são mantissa, a precisão máxima é de 52 casas decimais em representação binária ou 16 casas decimais. Por que existe um código para isso?

"A teoria sem prática é morta e infrutífera, a prática sem teoria é inútil e perniciosa". E abundam todos os tipos de coisas interessantes com números flutuantes:

float a, b, f;
a=123456789;
b=123456788;    
f=a-b;
cout << f;
// cout: 8

[Sergei Vladimirov]

pavlick_:
"A teoria sem prática é morta e infrutífera, a prática sem teoria é inútil e prejudicial". E há toda sorte de coisas interessantes com números flutuantes:

Achei que talvez você estivesse esperando algo único na MKL.

E toda essa coisa do transbordo de mantissa é interessante. Para a primeira série. )

void OnStart()
{
        float f1 = (float)1.1;
        float f2 = (float)2.2;
        float f3 = (float)3.3;
        
        if((f1 * f2) * f3 == f1 * (f2 * f3))
                Print("Выражения равны.");
        else
                Print("Нифига не равны!");
}

[pavlick_]

Para a primeira série. )

Claro, diga-nos, a maioria dos programadores não está a par do assunto, e eu mesmo tenho algumas lacunas.

[Sergei Vladimirov]

pavlick_:
É claro, diga-me, a maioria dos programadores não está a par do assunto, eu mesmo tenho algumas lacunas.

Bem, não sei, fomos treinados em aritmética binária para que ela ficasse presa em nossas cabeças por toda a vida. ) Outra coisa é que nem todos nós somos programadores. Em geral, você não acha que minha pergunta é algum tipo de pedra em seu jardim, apenas pensei que o propósito de seu programa - ver algumas diferenças no MCL em relação ao padrão, por isso perguntei.

[pavlick_]

int main(){
  // МКЛ аналог numeric_limits<float>::epsilon() - FLT_EPSILON
  float a = (float)10 + numeric_limits<float>::epsilon();
  float b = (float)1 + numeric_limits<float>::epsilon();
  float c = (float)0.5 + numeric_limits<float>::epsilon();
  print_float(a);
  print_float(b);
  print_float(c);
}

----a--------------
value = 10
mantissa 24:
1,01000000000000000000000
exponenta - 127 = 3

мантиса без прибавки эпсилон:
1,01000000000000000000000
----b--------------
value = 1.0000001192092896
mantissa 24:
1,00000000000000000000001
exponenta - 127 = 0

мантиса без прибавки эпсилон:
1,00000000000000000000000
----c--------------
 value = 0.50000011920928955
mantissa 24:
1,00000000000000000000010
exponenta - 127 = -1

мантиса без прибавки эпсилон:
1,00000000000000000000000