Чому в Python 3 добре виглядає значення з плаваючою комою 4 * 0,1, але 3 * 0,1 не відповідає?

Я знаю, що більшість десяткових знаків не мають точного подання з плаваючою комою ( Чи порушена математика з плаваючою комою? ).

Але я не бачу, чому так 4*0.1добре друкується 0.4, але 3*0.1ні, коли обидва значення насправді мають некрасиві десяткові зображення:

>>> 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')

Проста відповідь полягає в тому, що 3*0.1 != 0.3через помилку квантування (округлення) (тоді 4*0.1 == 0.4як множення на потужність двох зазвичай є "точною" операцією).

Ви можете використовувати .hexметод в Python для перегляду внутрішнього подання числа (в основному, точне двійкове значення з плаваючою комою, а не наближення бази-10). Це може допомогти пояснити, що відбувається під кришкою.

>>> (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 дорівнює 0x1,999999999999a разів 2 ^ -4. "А" в кінці означає цифру 10 - іншими словами, 0,1 у двійковій плаваючій точці дуже трохи більше, ніж "точне" значення 0,1 (оскільки кінцеве значення 0x0,99 округляється до 0x0.a). Коли ви помножите це на 4, потужність дві, показник зміщується вгору (від 2 ^ -4 до 2 ^ -2), але число інакше не змінюється, так 4*0.1 == 0.4.

Однак, якщо ви помножите на 3, маленька крихітна різниця між 0x0,99 та 0x0.a0 (0x0,07) збільшується до помилки 0x0,15, яка відображається як одноцифрова помилка в останньому положенні. Це призводить до того, що 0,1 * 3 буде дещо більшим, ніж округлене значення 0,3.

Поплавок Python 3 reprрозроблений таким чином, що він може бути зворотним , тобто показане значення повинно бути точно конвертоване в початкове значення. Тому він не може відображати 0.3і 0.1*3точно таким же чином, або дві різні цифри будуть в кінцевому підсумку те ж саме після того, як кругообіг. Отже, reprдвигун Python 3 вирішує відображати його з невеликою явною помилкою.

repr(і strв Python 3) викладе стільки цифр, скільки потрібно, щоб зробити значення однозначним. У цьому випадку результат множення 3*0.1не є найближчим до значення 0,3 (0x1,3333333333333p-2 у шістнадцятковій формі), це насправді на один LSB вище (0x1,3333333333334p-2), тому для розрізнення його потрібно більше цифр.

З іншого боку, множення 4*0.1 робить отримати найбільш близьке значення 0,4 (0x1.999999999999ap-2 в шістнадцятковій формі ), так що не потрібно ніяких додаткових цифр.

Ви можете перевірити це досить легко:

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

Я використовував шістнадцяткові позначення, тому що це приємно і компактно і показує різницю між двома значеннями. Ви можете зробити це самостійно, використовуючи напр (3*0.1).hex(). Якщо ви хочете побачити їх у всій їх десятковій красі, ось вам:

>>> 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')

Ось спрощений висновок з інших відповідей.

Якщо ви перевіряєте поплавок у командному рядку Python або друкуєте його, він проходить через функцію, reprяка створює його рядкове подання.

Починаючи з версії 3.2, Python strі reprвикористовує складну схему округлення, яка, якщо можливо, віддає перевагу приємним децималам, але використовує більше цифр, де це необхідно, щоб гарантувати бієктивне (однозначне) відображення між поплавками та їх рядковими зображеннями.

Ця схема гарантує, що значення repr(float(s))виглядає добре для простих десяткових знаків, навіть якщо вони не можуть бути представлені точно як поплавці (наприклад, коли s = "0.1").

У той же час він гарантує, що float(repr(x)) == xтримається за кожен поплавокx

Насправді не характерно для реалізації Python, але має застосовуватися до будь-яких функцій поплавця до десяткових рядків.

Число з плаваючою комою є по суті двійковим числом, але в наукових позначеннях із фіксованою межею значущих цифр.

Зворотне будь-яке число, яке має простий коефіцієнт числа, яке не поділяється з базою, завжди призведе до повторного подання точкових точок. Наприклад, 1/7 має простий коефіцієнт 7, який не поділяється на 10, а тому має повторне десяткове подання, і те саме стосується 1/10 з простими множниками 2 і 5, останній не ділиться з 2 ; це означає, що 0,1 не може бути точно представлений кінцевою кількістю бітів після крапки.

Оскільки 0,1 не має точного подання, функція, яка перетворює наближення до рядка з десятковою точкою, зазвичай намагається наблизити певні значення, щоб вони не отримували інтуїтивні результати, наприклад, 0,1000000000004121.

Оскільки плаваюча точка знаходиться в науковій нотації, будь-яке множення на силу основи впливає лише на експонентну частину числа. Наприклад, 1,231e + 2 * 100 = 1,231e + 4 для десяткової нотації, а також 1,00101010e11 * 100 = 1,00101010e101 у двійковій нотації. Якщо я помножую на не-потужність бази, це також вплине на значні цифри. Наприклад, 1,2e1 * 3 = 3,6e1

Залежно від використовуваного алгоритму, він може спробувати відгадати загальні десяткові знаки лише на основі значущих цифр. І 0,1, і 0,4 мають однакові значні цифри у двійкових, оскільки їх поплавці по суті є усіченнями (8/5) (2 ^ -4) та (8/5) (2 ^ -6) відповідно. Якщо алгоритм ідентифікує шаблон сигфіг 8/5 як десятковий 1.6, він буде працювати на 0,1, 0,2, 0,4, 0,8 і т.д. Він може також мати магічні шаблони сигфіг для інших комбінацій, наприклад, поплавок 3, поділений на поплавок 10 та інші магічні візерунки, статистично ймовірно, будуть сформовані діленням на 10.

У випадку 3 * 0,1 останні кілька значущих цифр, ймовірно, будуть відрізнятися від ділення поплавця 3 на поплавок 10, внаслідок чого алгоритм не може розпізнати магічне число для константи 0,3 залежно від його допуску до втрати точності.

Редагувати: https://docs.python.org/3.1/tutorial/floatingpoint.html

Цікаво, що існує багато різних десяткових чисел, які поділяють однаковий найближчий приблизний двійковий дріб. Наприклад, числа 0,1 і 0,10000000000000001 та 0,1000000000000000055511151231257827021181583404541015625 всі наближені на 3602879701896397/2 ** 55. Оскільки всі ці десяткові значення мають однакове наближення, будь-яке з них може бути відображене при збереженні інваріантного рівня (repr (x)) ) == х.

Немає допуску до втрати точності, якщо float x (0,3) не точно дорівнює float y (0,1 * 3), то repr (x) точно не дорівнює repr (y).