Arrondir les nombres dans MT4 via NormalizeDouble - page 17

[Sergei Vladimirov]

pavlick_:

J'ai écrit un petit code d'entraînement (j'avais envie de farfouiller moi-même) qui permet de découvrir l'intérieur d'un nombre flottant.

La sortie à f == 0.5 + 1/(2^24). 1/(2^24) est le plus jeune chiffre de la mantisse à un degré donné :

Que vouliez-vous voir exactement là-bas ? Les nombres flottants ont un bit par signe, 8 bits par exposant, et les 23 restants sont la mantisse, c'est-à-dire que la précision maximale est de 23 décimales en représentation binaire, ou 7 décimales. Pour les nombres doubles, il y a 1 bit par signe, 11 bits par exposant, les 52 bits restants sont la mantisse, la précision maximale est de 52 décimales en représentation binaire ou de 16 décimales. Pourquoi y a-t-il un code pour cela ?

[pavlick_]

Sergei Vladimirov:

Que vouliez-vous voir exactement là-bas ? Les nombres flottants ont un bit par signe, 8 bits par exposant, les 23 restants sont la mantisse, soit une précision maximale de 23 décimales en représentation binaire, ou 7 décimales. Pour les nombres doubles, il y a 1 bit par signe, 11 bits par exposant, les 52 bits restants sont la mantisse, la précision maximale est de 52 décimales en représentation binaire ou de 16 décimales. Pourquoi y a-t-il un code pour cela ?

"La théorie sans la pratique est morte et infructueuse, la pratique sans la théorie est inutile et pernicieuse." Et toutes sortes de choses intéressantes avec les nombres flottants abondent :

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

[Sergei Vladimirov]

pavlick_:
"La théorie sans la pratique est morte et infructueuse, la pratique sans la théorie est inutile et préjudiciable." Et il y a toutes sortes de choses intéressantes avec les nombres flottants :

J'ai juste pensé que peut-être tu t'attendais à quelque chose d'unique dans MKL.

Et toute l'histoire du débordement de la mantisse est intéressante. Pour la première année. )

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_]

Pour la première année. )

Bien sûr, dites-nous, la plupart des programmeurs ne sont pas au fait du sujet, et j'ai moi-même quelques lacunes.

[Sergei Vladimirov]

pavlick_:
Bien sûr, dites-moi, la plupart des programmeurs ne sont pas au point sur le sujet, j'ai moi-même quelques lacunes.

Eh bien, je ne sais pas, nous avons été formés à l'arithmétique binaire pour que cela reste dans nos têtes toute notre vie. ) Une autre chose est que nous ne sommes pas tous des programmeurs. En général, vous ne pensez pas que ma question est une sorte de pierre dans votre jardin, j'ai juste pensé que le but de votre programme - voir quelques différences dans le MCL par rapport à la norme, donc j'ai demandé.

[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