Почему плавающее число отличается каждые сотни?

Question

Я наткнулся на некоторую точность "ошибки" при использовании плавающего числа в Python, и когда мне захотелось немного поиграть с ним, я обнаружил странный паттерн.

Это небольшая плавающая проблема:

1.15 * 100  # Returns 114.99999999999999

Итак, я попытался с * 1, затем * 10, и это число было правильным (показывает 15, а не 14 ...).

Но когда я запустил скрипт для отобразить кратные 10 для этого числа, вот что я нашел:

lvl = 1
for i in range(0, 15):
    lvl = lvl * 10
    1.15 * lvl

Показано следующее:

11.5 # 10
114.99999999999999 # 100
1150.0 # 1.000
11500.0 # 10.000
114999.99999999999 # 100.000
1150000.0 # 1.000.000
11500000.0 # 10.000.000
114999999.99999999 # 100.000.000
1150000000.0 # 1.000.000.000
11500000000.0 # 10.000.000.000
114999999999.99998 # 100.000.000.000
1150000000000.0 # 1.000.000.000.000
11500000000000.0 # 10.000.000.000.000
114999999999999.98 # 100.000.000.000.000
1150000000000000.0 # 1.000.000.000.000.000

Что меня беспокоит, так это то, что плавающее число меняется с 15 на 14 когда множитель равен «сотням» чего-либо (сотни, сотни тысяч, сотни миллионов и т. Д. c).

Почему это так? Почему сотни?

Answer 1

Когда 1.15 конвертируется в формат IEEE-754 binary64, результат в шестнадцатеричном виде равен 0x1.2666666666666. (1.15 - это 23/20, и он имеет повторяющийся шаблон в шестнадцатеричном формате по той же причине, что 2/3 имеет повторяющийся шаблон в десятичном формате.) Обратите внимание, что это число имеет 53 бита в своем значении, включая последний 0 бит - из ведя 1 к младшему биту из последних 6, получается 53 бита.

Это значение немного ниже 1,15; это 1,149999999999999911182158029987476766109466552734375. Когда мы умножим это на степени 10, результаты с действительными числами будут 11,4999 ..., 114,999 ... и так далее. Единственный способ получить результат, в котором значащие цифры равны 115, заключается в том, что умножение округляется при округлении произведения до формата с плавающей запятой.

Обратите внимание, что в 0x1.2666666666666 есть шаблон, который повторяется каждые четыре бита. Итак, если бы мы округлили это до последнего бита, затем со второго до последнего бита, затем с третьего до последнего и т. Д., Мы увидели бы схему, повторяющуюся каждые четыре члена.

Однако, мы умножаем на 10, 100, 1000 и так далее. Учтите, что log ₂ 10 составляет около 3.322, чуть меньше 3⅓. (Эквивалентно, 10 ³ = 1000 близко к 2 ¹⁰ = 1024.) Так что, где силы 10 l ie относительно степеней 2 имеют шаблон, повторяющийся каждые три члена до складываются дроби:

• 2 ³ ≤ 10 ¹ <2 <sup>4 .
• 2 ⁶ ≤ 10 ² <2 <sup>7 , на 3 больше, чем предыдущий.
• 2 ⁹ ≤ 10 ³ <2 <sup>10 , на 3 больше, чем предыдущий.
• 2 ¹³ ≤ 10 ⁴ <2 <sup>14 , 4 больше, чем предыдущий.
• 2 ¹⁶ ≤ 10 ⁵ <2 <sup>17 , на 3 больше, чем предыдущий.
• 2 ¹⁹ ≤ 10 ⁶ <2 <sup>20 , на 3 больше, чем предыдущие.
• 2 ²³ ≤ 10 ⁷ <2 <sup>24 , на 4 больше, чем предыдущие.
• 2 ²⁶ ≤ 10 ⁸ <2 <sup>27, На 3 больше, чем предыдущий.
• 2 ²⁹ ≤ 10 ⁹ <2 <sup>30 , на 3 больше, чем предыдущий.
• 2 ³³ ≤ 10 ¹⁰ <2 <sup>34 , на 4 больше, чем предыдущие.

Таким образом, до тех пор, пока проблема аппроксимации не нарушит эту модель, полномочия десяти образуют « каждый четвертый ”битовый паттерн с циклом из трех степеней по десять.

(здесь я опустил некоторые детали - на самом деле важны степени пяти, поскольку они влияют на значащие цифры результатов, и это это те важные цифры, которые должны быть округлены, а не числа десяти. Но это не математическое доказательство, и не может быть, потому что образец не продолжается долго; это просто совпадение в небольшом регионе, поэтому это объяснение просто предназначено для интуитивного объяснения совпадения.)

Итак, мы видим, что в цикле из трех слагаемых два из них округляются вверх и производят значащие цифры в 115, и одна из них округляется и выдает 114,999 .... Это просто совпадение, а не глубокая математическая истина.