Arrotondamento dei numeri in MT4 tramite NormalizeDouble - pagina 17

[Sergei Vladimirov]

pavlick_:

Ho scritto un po' di codice di allenamento (ero interessato a curiosare io stesso) che scopre l'interno del numero fluttuante.

L'uscita a f == 0,5 + 1/(2^24). 1/(2^24) è la cifra più giovane della mantissa ad un dato grado:

Cosa volevi vedere esattamente lì? I numeri float hanno un bit per segno, 8 bit per esponente, e i restanti 23 sono mantissa, cioè la precisione massima è di 23 cifre decimali nella rappresentazione binaria, o 7 cifre decimali. Per i numeri doppi, c'è 1 bit per segno, 11 bit per esponente, i restanti 52 bit sono mantissa, la precisione massima è di 52 cifre decimali nella rappresentazione binaria o 16 cifre decimali. Perché c'è un codice per questo?

[pavlick_]

Sergei Vladimirov:

Cosa volevi vedere esattamente lì? I numeri float hanno un bit per segno, 8 bit per esponente, i restanti 23 sono mantissa, cioè la massima precisione di 23 cifre decimali nella rappresentazione binaria, o 7 cifre decimali. Per i numeri doppi, c'è 1 bit per segno, 11 bit per esponente, i restanti 52 bit sono mantissa, la precisione massima è di 52 cifre decimali nella rappresentazione binaria o 16 cifre decimali. Perché c'è un codice per questo?

"La teoria senza la pratica è morta e infruttuosa, la pratica senza la teoria è inutile e perniciosa". E tutti i tipi di cose interessanti con i numeri fluttuanti abbondano:

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

[Sergei Vladimirov]

pavlick_:
"La teoria senza la pratica è morta e infruttuosa, la pratica senza la teoria è inutile e dannosa". E c'è tutta una serie di cose interessanti con i numeri fluttuanti:

Ho solo pensato che forse vi aspettavate qualcosa di unico in MKL.

E tutta la questione dell'overflow della mantissa è interessante. Per la prima elementare. )

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

Per il primo grado. )

Certo, diccelo, la maggior parte dei programmatori non è aggiornata sull'argomento, e io stesso ho delle lacune.

[Sergei Vladimirov]

pavlick_:
Naturalmente, ditemi, la maggior parte dei programmatori non sono aggiornati sull'argomento, io stesso ho delle lacune.

Beh, non so, siamo stati addestrati all'aritmetica binaria in modo che ci sia rimasta in testa per tutta la vita. ) Un'altra cosa è che non tutti noi siamo programmatori. In generale, non pensate che la mia domanda sia una sorta di pietra nel vostro giardino, ho solo pensato che lo scopo del vostro programma - per vedere alcune differenze nella MCL dallo standard, così ho chiesto.

[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