(int) átalakítás hiba 0.7 esetében (szabofe)

(int) ((0.0 + 0.7) * 10) eredmény: ?? 7 ??
(int) ((0.1 + 0.7) * 10) eredmény: ?? 7 ??
(int) ((0.2 + 0.7) * 10) eredmény: ?? 9 ??
(int) ((0.3 + 0.7) * 10) eredmény: ?? 10 ??
(int) ((0.4 + 0.7) * 10) eredmény: ?? 11 ??
(int) ((0.5 + 0.7) * 10) eredmény: ?? 12 ??
(int) ((0.6 + 0.7) * 10) eredmény: ?? 12 ??
(int) ((0.7 + 0.7) * 10) eredmény: ?? 14 ??
(int) ((0.8 + 0.7) * 10) eredmény: ?? 15 ??
(int) ((0.9 + 0.7) * 10) eredmény: ?? 16 ??

A kód összeállításakor vagy értelmezésénél a "tizedes" értékek már a formátum legközelebbi számához vannak kerekítve, ami még a számítás előtt történik, így ez számolási eltérést, kerekítési "hibát" eredményez.

A "0.0" => 0,    A "0.1" => 0.10000000000000001,    A "0.2" => 0.20000000000000001,    A "0.3" => 0.29999999999999999,    A "0.4" => 0.40000000000000002,    
A "0.5" => 0.5,    A "0.6" => 0.59999999999999998,    A "0.7" => 0.69999999999999996,    A "0.8" => 0.80000000000000004,    A "0.9" => 0.90000000000000002,    

A teszt futtatásának részletes adatai.

A (0.0 + 0.7) eredménye számolva "0.69999999999999996"
A (0.0 + 0.7) eredményének "0.7" értéknek kell lennie,
Azaz a kettő => Egyenlő
&
A ((0.0 + 0.7)*10) eredménye számolva "7"
A ((0.0 + 0.7)*10) eredményének "7" értéknek kell lennie,
Azaz a kettő => Egyenlő

A (0.1 + 0.7) eredménye számolva "0.79999999999999993"
A (0.1 + 0.7) eredményének "0.8" értéknek kell lennie,
Azaz a kettő => Nem egyenlő
&
A ((0.1 + 0.7)*10) eredménye számolva "7.9999999999999991"
A ((0.1 + 0.7)*10) eredményének "8" értéknek kell lennie,
Azaz a kettő => Nem egyenlő

A (0.2 + 0.7) eredménye számolva "0.89999999999999991"
A (0.2 + 0.7) eredményének "0.9" értéknek kell lennie,
Azaz a kettő => Nem egyenlő
&
A ((0.2 + 0.7)*10) eredménye számolva "9"
A ((0.2 + 0.7)*10) eredményének "9" értéknek kell lennie,
Azaz a kettő => Egyenlő

A (0.3 + 0.7) eredménye számolva "1"
A (0.3 + 0.7) eredményének "1.0" értéknek kell lennie,
Azaz a kettő => Egyenlő
&
A ((0.3 + 0.7)*10) eredménye számolva "10"
A ((0.3 + 0.7)*10) eredményének "10" értéknek kell lennie,
Azaz a kettő => Egyenlő

A (0.4 + 0.7) eredménye számolva "1.1000000000000001"
A (0.4 + 0.7) eredményének "1.1" értéknek kell lennie,
Azaz a kettő => Egyenlő
&
A ((0.4 + 0.7)*10) eredménye számolva "11"
A ((0.4 + 0.7)*10) eredményének "11" értéknek kell lennie,
Azaz a kettő => Egyenlő

A (0.5 + 0.7) eredménye számolva "1.2"
A (0.5 + 0.7) eredményének "1.2" értéknek kell lennie,
Azaz a kettő => Egyenlő
&
A ((0.5 + 0.7)*10) eredménye számolva "12"
A ((0.5 + 0.7)*10) eredményének "12" értéknek kell lennie,
Azaz a kettő => Egyenlő

A (0.6 + 0.7) eredménye számolva "1.2999999999999998"
A (0.6 + 0.7) eredményének "1.3" értéknek kell lennie,
Azaz a kettő => Nem egyenlő
&
A ((0.6 + 0.7)*10) eredménye számolva "12.999999999999998"
A ((0.6 + 0.7)*10) eredményének "13" értéknek kell lennie,
Azaz a kettő => Nem egyenlő

A (0.7 + 0.7) eredménye számolva "1.3999999999999999"
A (0.7 + 0.7) eredményének "1.4" értéknek kell lennie,
Azaz a kettő => Egyenlő
&
A ((0.7 + 0.7)*10) eredménye számolva "14"
A ((0.7 + 0.7)*10) eredményének "14" értéknek kell lennie,
Azaz a kettő => Egyenlő

A (0.8 + 0.7) eredménye számolva "1.5"
A (0.8 + 0.7) eredményének "1.5" értéknek kell lennie,
Azaz a kettő => Egyenlő
&
A ((0.8 + 0.7)*10) eredménye számolva "15"
A ((0.8 + 0.7)*10) eredményének "15" értéknek kell lennie,
Azaz a kettő => Egyenlő

A (0.9 + 0.7) eredménye számolva "1.6000000000000001"
A (0.9 + 0.7) eredményének "1.6" értéknek kell lennie,
Azaz a kettő => Egyenlő
&
A ((0.9 + 0.7)*10) eredménye számolva "16"
A ((0.9 + 0.7)*10) eredményének "16" értéknek kell lennie,
Azaz a kettő => Egyenlő


Megjegyzés: A lebegőpontos ábrázolás okán a törtek értéke véges pontosságú. Ezen felül az (int) "csonkítása" miatt jelenkezik adott értékeknél a "hiba", melyről a kérdésem szólt.
Talán mindez jól látszik a fenti tesztben is...
















D O