Dlaczego wartość zmiennoprzecinkowa 4 * 0,1 wygląda ładnie w Pythonie 3, a 3 * 0,1 nie?

Wiem, że większość liczb dziesiętnych nie ma dokładnej reprezentacji zmiennoprzecinkowej ( czy matematyka zmiennoprzecinkowa jest zepsuta? ).

Ale nie rozumiem, dlaczego 4*0.1jest ładnie drukowane 0.4, ale 3*0.1nie jest, gdy obie wartości mają w rzeczywistości brzydkie reprezentacje dziesiętne:

>>> 3*0.1
0.30000000000000004
>>> 4*0.1
0.4
>>> from decimal import Decimal
>>> Decimal(3*0.1)
Decimal('0.3000000000000000444089209850062616169452667236328125')
>>> Decimal(4*0.1)
Decimal('0.40000000000000002220446049250313080847263336181640625')

Prosta odpowiedź jest taka, ponieważ z 3*0.1 != 0.3powodu błędu kwantyzacji (zaokrąglenia) (podczas gdy4*0.1 == 0.4 gdy mnożenie przez potęgę dwójki jest zwykle operacją „dokładną”).

Możesz użyć tej .hexmetody w Pythonie, aby wyświetlić wewnętrzną reprezentację liczby (w zasadzie dokładną binarną wartość zmiennoprzecinkową zamiast przybliżenia podstawy 10). Może to pomóc wyjaśnić, co się dzieje pod maską.

>>> (0.1).hex()
'0x1.999999999999ap-4'
>>> (0.3).hex()
'0x1.3333333333333p-2'
>>> (0.1*3).hex()
'0x1.3333333333334p-2'
>>> (0.4).hex()
'0x1.999999999999ap-2'
>>> (0.1*4).hex()
'0x1.999999999999ap-2'

0,1 to 0x1.999999999999a razy 2 ^ -4. „A” na końcu oznacza cyfrę 10 - innymi słowy, 0,1 binarnie zmiennoprzecinkowe jest bardzo nieznacznie większe niż „dokładna” wartość 0,1 (ponieważ końcowe 0x0,99 jest zaokrąglane w górę do 0x0.a). Kiedy pomnożymy to przez 4, potęgę dwóch, wykładnik przesuwa się w górę (z 2 ^ -4 do 2 ^ -2), ale poza tym liczba pozostaje niezmieniona, więc4*0.1 == 0.4 .

Jednak gdy pomnożymy przez 3, niewielka różnica między 0x0.99 a 0x0.a0 (0x0.07) powiększa się do błędu 0x0,15, który pojawia się jako jednocyfrowy błąd na ostatniej pozycji. Powoduje to, że 0,1 * 3 jest bardzo nieznacznie większe niż zaokrąglona wartość 0,3.

Zmienna zmiennoprzecinkowa Pythona 3 reprzostała zaprojektowana tak, aby była możliwa do przełączenia w obie strony , to znaczy pokazana wartość powinna być dokładnie zamienialna na wartość oryginalną. W związku z tym nie może wyświetlać 0.3i 0.1*3dokładnie w ten sam sposób, w przeciwnym razie dwie różne liczby zakończyłyby się tak samo po zadziałaniu w obie strony. W rezultacie reprsilnik Pythona 3 wybiera wyświetlanie jednego z niewielkim widocznym błędem.

repr(oraz strw Pythonie 3) wypisze tyle cyfr, ile potrzeba, aby wartość była jednoznaczna. W tym przypadku wynik mnożenia3*0.1 nie jest najbliższą wartości 0,3 (0x1,33333333333p-2 w zapisie szesnastkowym), w rzeczywistości jest o jeden LSB wyższy (0x1,3333333333334p-2), więc potrzeba więcej cyfr, aby odróżnić go od 0,3.

Z drugiej strony mnożenie 4*0.1 daje wartość najbliższą 0,4 (0x1.999999999999ap-2 w zapisie szesnastkowym), więc nie wymaga żadnych dodatkowych cyfr.

Możesz to dość łatwo zweryfikować:

>>> 3*0.1 == 0.3
False
>>> 4*0.1 == 0.4
True

Użyłem powyższej notacji szesnastkowej, ponieważ jest ładny i zwarty i pokazuje różnicę bitową między tymi dwiema wartościami. Możesz to zrobić samodzielnie używając np (3*0.1).hex(). Jeśli wolisz zobaczyć je w całej ich dziesiętnej okazałości, proszę bardzo:

>>> Decimal(3*0.1)
Decimal('0.3000000000000000444089209850062616169452667236328125')
>>> Decimal(0.3)
Decimal('0.299999999999999988897769753748434595763683319091796875')
>>> Decimal(4*0.1)
Decimal('0.40000000000000002220446049250313080847263336181640625')
>>> Decimal(0.4)
Decimal('0.40000000000000002220446049250313080847263336181640625')

Oto uproszczony wniosek z innych odpowiedzi.

Jeśli zaznaczysz zmiennoprzecinkowy w wierszu poleceń Pythona lub wydrukujesz go, przejdzie on przez funkcję, reprktóra tworzy swoją reprezentację w postaci ciągu.

Począwszy od wersji 3.2, Python strirepr używanie złożonego systemu zaokrąglania, która preferuje ładną dziesiętne jeśli to możliwe, ale wymaga więcej cyfr, gdzie niezbędne do bijective gwarancji (jeden do jednego) mapowanie pomiędzy pływaków i ich reprezentacje smyczkowych.

Ten schemat gwarantuje, że wartość repr(float(s))wygląda ładnie dla prostych liczb dziesiętnych, nawet jeśli nie można ich dokładnie przedstawić jako liczby zmiennoprzecinkowe (np. Kiedy s = "0.1").

Jednocześnie gwarantuje utrzymanie float(repr(x)) == xkażdego spławikax

Niezbyt specyficzne dla implementacji Pythona, ale powinno mieć zastosowanie do wszystkich funkcji typu float do dziesiętnych funkcji łańcuchowych.

Liczba zmiennoprzecinkowa jest zasadniczo liczbą binarną, ale w notacji naukowej z ustalonym limitem cyfr znaczących.

Odwrotność dowolnej liczby, która ma współczynnik liczby pierwszej, który nie jest dzielony z podstawą, zawsze spowoduje powtarzającą się reprezentację kropki. Na przykład 1/7 ma czynnik pierwszy, 7, który nie jest dzielony z 10, a zatem ma powtarzającą się reprezentację dziesiętną, i to samo dotyczy 1/10 z czynnikami pierwszymi 2 i 5, które nie są dzielone z 2 ; oznacza to, że 0,1 nie może być dokładnie reprezentowane przez skończoną liczbę bitów po kropce.

Ponieważ 0.1 nie ma dokładnej reprezentacji, funkcja, która konwertuje przybliżenie na ciąg przecinka dziesiętnego, zwykle próbuje aproksymować pewne wartości, aby nie uzyskać nieintuicyjnych wyników, takich jak 0,1000000000004121.

Ponieważ liczba zmiennoprzecinkowa jest zapisana w notacji naukowej, mnożenie przez potęgę podstawy wpływa tylko na wykładnik liczby. Na przykład 1,231e + 2 * 100 = 1,231e + 4 dla notacji dziesiętnej i podobnie 1,00101010e11 * 100 = 1,00101010e101 w notacji binarnej. Jeśli pomnożę przez nie potęgę podstawy, wpłynie to również na cyfry znaczące. Na przykład 1,2e1 * 3 = 3,6e1

W zależności od zastosowanego algorytmu może próbować odgadnąć typowe liczby dziesiętne na podstawie tylko cyfr znaczących. Zarówno 0,1, jak i 0,4 mają te same cyfry znaczące w systemie dwójkowym, ponieważ ich liczby zmiennoprzecinkowe są zasadniczo obcięciami odpowiednio (8/5) (2 ^ -4) i (8/5) (2 ^ -6). Jeśli algorytm zidentyfikuje wzorzec sigfig 8/5 jako dziesiętną 1,6, to będzie działał na 0,1, 0,2, 0,4, 0,8 itd. Może również mieć magiczne wzorce sigfig dla innych kombinacji, takich jak liczba zmiennoprzecinkowa 3 podzielona przez liczbę zmiennoprzecinkową 10 i inne magiczne wzorce, które statystycznie prawdopodobnie zostaną utworzone przez podzielenie przez 10.

W przypadku 3 * 0,1 kilka ostatnich cyfr znaczących prawdopodobnie będzie się różnić od dzielenia liczby zmiennoprzecinkowej 3 przez liczbę zmiennoprzecinkową 10, co spowoduje, że algorytm nie rozpozna magicznej liczby dla stałej 0,3 w zależności od tolerancji utraty precyzji.

Edycja: https://docs.python.org/3.1/tutorial/floatingpoint.html

Co ciekawe, istnieje wiele różnych liczb dziesiętnych, które mają ten sam najbliższy ułamek dwójkowy. Na przykład liczby 0,1 i 0,10000000000000001 i 0,1000000000000000055511151231257827021181583404541015625 są wszystkie w przybliżeniu przybliżone przez 3602879701896397/2 ** 55. Ponieważ wszystkie te wartości dziesiętne mają to samo przybliżenie, każda z nich może zostać wyświetlona przy jednoczesnym zachowaniu odwrotnej (odwrotnej) ) == x.

Nie ma tolerancji dla utraty precyzji, jeśli float x (0,3) nie jest dokładnie równe float y (0,1 * 3), to repr (x) nie jest dokładnie równe repr (y).