Який найкращий спосіб порівняти поплавці для майже рівності в Python?

Добре відомо, що порівняння поплавків для рівності трохи хитро пов'язане із питаннями округлення та точності.

Наприклад: https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/

Який рекомендований спосіб боротьби з цим у Python?

Напевно, є для цього десь стандартна функція бібліотеки?

Python 3.5 додає math.iscloseта cmath.iscloseфункції, як описано в PEP 485 .

Якщо ви використовуєте більш ранню версію Python, еквівалентна функція задана в документації .

def isclose(a, b, rel_tol=1e-09, abs_tol=0.0):
    return abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

rel_tolє відносною толерантністю, її множать на більшу величину двох аргументів; як значення збільшуються, так і дозволена різниця між ними, вважаючи їх рівними.

abs_tol- це абсолютна толерантність, яка застосовується так, як є у всіх випадках. Якщо різниця менша за будь-який з цих допусків, значення вважаються рівними.

Невже щось таке просте, як наступне, недостатньо добре?

return abs(f1 - f2) <= allowed_error

Я погодився б, що відповідь Гарета, ймовірно, найбільш підходить як легка функція / рішення.

Але я подумав, що було б корисно зауважити, що якщо ви використовуєте NumPy або обмірковуєте це, для цього існує функція, що пакує.

numpy.isclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False)

Трохи відмови від відповідальності: установка NumPy може бути нетривіальним досвідом залежно від вашої платформи.

Використовуйте decimalмодуль Python , який забезпечує Decimalклас.

З коментарів:

Варто зауважити, що якщо ви займаєтесь математично важкою роботою і вам абсолютно не потрібна точність від десяткової, це може насправді заблукати речі. Поплавки - це шлях, набагато швидше впоратися, але неточно. Десяткові знаки надзвичайно точні, але повільні.

Мені нічого не відомо в стандартній бібліотеці Python (або в іншому місці), що реалізує AlmostEqual2sComplementфункцію Доусона . Якщо така поведінка ви хочете, вам доведеться реалізувати її самостійно. (В цьому випадку, замість того щоб використовувати розумні бітові хак Доусона ви, ймовірно , краще використовувати більш традиційні випробування форми if abs(a-b) <= eps1*(abs(a)+abs(b)) + eps2або аналогічної Щоб отримати Dawson поведінку як ви могли б сказати що - щось на зразок. if abs(a-b) <= eps*max(EPS,abs(a),abs(b))Для деяких малих фіксованого EPS, це не зовсім те саме, що і Доусон, але схоже за духом.

Поширена думка, що числа з плаваючою комою не можна порівнювати за рівність, є неточною. Числа з плаваючою комою нічим не відрізняються від цілих чисел: якщо ви оціните "a == b", ви отримаєте істинні, якщо вони однакові числа, а помилкові - інакше (з розумінням того, що два NaN, звичайно, не однакові числа).

Справжня проблема полягає в наступному: якщо я зробив деякі розрахунки і не впевнений, що два числа, які я повинен порівняти, є абсолютно правильними, то що? Ця проблема однакова для плаваючої точки, як і для цілих чисел. Якщо ви оціните цілочисельний вираз "7/3 * 3", він не буде порівняти рівним "7 * 3/3".

Отже, припустимо, ми запитали "Як я порівняю цілі числа для рівності?" в такій ситуації. Єдиної відповіді немає; що ви повинні зробити, залежить від конкретної ситуації, зокрема, які помилки у вас є і що ви хочете досягти.

Ось кілька можливих варіантів.

Якщо ви хочете отримати "справжній" результат, якщо математично точні числа були б рівними, ви можете спробувати використати властивості обчислень, які ви виконуєте, щоб довести, що ви отримуєте однакові помилки в двох числах. Якщо це можливо, і ви порівнюєте два числа, які є результатами виразів, які давали б однакові числа, якщо обчислити точно, то ви отримаєте "правду" від порівняння. Інший підхід полягає в тому, що ви можете проаналізувати властивості обчислень і довести, що помилка ніколи не перевищує певну суму, можливо, абсолютну суму або величину відносно одного з входів або одного з результатів. У такому випадку ви можете запитати, чи відрізняються два обчислені числа щонайменше на цю суму, і повернути "справжнє", якщо вони знаходяться в інтервалі. Якщо ви не можете довести помилку, ви можете здогадатися і сподіватися на найкраще. Один із способів здогадки - це оцінити багато випадкових вибірок і побачити, який розподіл ви отримаєте в результатах.

Звичайно, оскільки ми встановлюємо лише вимогу, що ти отримаєш "справжній", якщо математично точні результати рівні, ми залишаємо відкритими можливість отримати "справжні", навіть якщо вони нерівні. (Насправді, ми можемо задовольнити цю вимогу, завжди повертаючи "справжнє". Це робить розрахунок простим, але, як правило, небажаним, тому я обговорюю покращення ситуації нижче.)

Якщо ви хочете отримати "хибний" результат, якщо математично точні числа були б неоднаковими, вам потрібно довести, що ваша оцінка чисел дає різні числа, якщо математично точні числа були б неоднаковими. Це може бути неможливим для практичних цілей у багатьох загальних ситуаціях. Тож розглянемо альтернативу.

Корисною вимогою може бути те, що ми отримуємо "помилковий" результат, якщо математично точні числа відрізняються більш ніж на певну суму. Наприклад, можливо, ми збираємося обчислити, куди їхав м'яч, кинутий у комп’ютерній грі, і ми хочемо знати, чи вдарив він у біту. У цьому випадку ми, безумовно, хочемо отримати "справжній", якщо м'яч вдарив битою, і ми хочемо отримати "помилковий", якщо м'яч далеко від бити, і ми можемо прийняти неправильну "справжню" відповідь, якщо м'яч в математично точне моделювання пропустило биту, але знаходиться в межах міліметра від удару кажана. У цьому випадку нам потрібно довести (або здогадатися / оцінити), що в нашому розрахунку положення м'яча і положення кажана є комбінована помилка не менше одного міліметра (для всіх цікавих позицій). Це дозволило б нам завжди повертатися "

Отже, те, як ви вирішите, що повернути, порівнюючи числа з плаваючою комою, дуже залежить від вашої конкретної ситуації.

Щодо того, як ви хочете довести межі помилок для розрахунків, це може бути складним предметом. Будь-яка реалізація з плаваючою комою, що використовує стандарт IEEE 754 в режимі "круглий-найближчий", повертає номер плаваючої точки, найближчий до точного результату для будь-якої основної операції (зокрема, множення, ділення, додавання, віднімання, квадратний корінь). (У випадку зв'язання, кругле, щоб низький біт був рівним.) (Будьте особливо обережні щодо квадратного кореня та поділу; ваша мовна реалізація може використовувати методи, які не відповідають IEEE 754 для них.) Через цю вимогу ми знаємо похибка в одному результаті становить щонайбільше 1/2 значення найменшого значущого біта. (Якби було більше, округлення перейшло б до іншого числа, яке знаходиться в межах 1/2 значення.)

Їхати звідти стає значно складніше; Наступним кроком є ​​виконання операції, коли на одному з входів вже є помилка. Для простих виразів ці помилки можна дотримуватися через обчислення, щоб досягти межі кінцевої помилки. На практиці це робиться лише в кількох ситуаціях, наприклад, робота над якісною математичною бібліотекою. І, звичайно, потрібен точний контроль над тим, які саме операції виконуються. Мови високого рівня часто дають компілятору велику слабкість, тому ви можете не знати, в якому порядку виконуються операції порядку.

Існує набагато більше, що можна було б написати (і є) на цю тему, але я мушу зупинитися на цьому. Підсумовуючи відповідь, така відповідь є: Бібліотечна процедура не існує для цього порівняння, оскільки не існує єдиного рішення, яке б відповідало більшості потреб, яке варто включити в розпорядження бібліотеки. (Якщо порівняння з відносним або абсолютним інтервалом помилок вам достатньо, ви можете зробити це просто без бібліотечної програми.)

Якщо ви хочете використовувати його в контексті тестування / TDD, я б сказав, що це стандартний спосіб:

from nose.tools import assert_almost_equals

assert_almost_equals(x, y, places=7) #default is 7

math.isclose () для цього додано Python 3.5 ( вихідний код ). Ось порт його для Python 2. Відмінність від однокласника Марка Рансома полягає в тому, що він може нормально обробляти "inf" і "-inf".

def isclose(a, b, rel_tol=1e-09, abs_tol=0.0):
    '''
    Python 2 implementation of Python 3.5 math.isclose()
    https://hg.python.org/cpython/file/tip/Modules/mathmodule.c#l1993
    '''
    # sanity check on the inputs
    if rel_tol < 0 or abs_tol < 0:
        raise ValueError("tolerances must be non-negative")

    # short circuit exact equality -- needed to catch two infinities of
    # the same sign. And perhaps speeds things up a bit sometimes.
    if a == b:
        return True

    # This catches the case of two infinities of opposite sign, or
    # one infinity and one finite number. Two infinities of opposite
    # sign would otherwise have an infinite relative tolerance.
    # Two infinities of the same sign are caught by the equality check
    # above.
    if math.isinf(a) or math.isinf(b):
        return False

    # now do the regular computation
    # this is essentially the "weak" test from the Boost library
    diff = math.fabs(b - a)
    result = (((diff <= math.fabs(rel_tol * b)) or
               (diff <= math.fabs(rel_tol * a))) or
              (diff <= abs_tol))
    return result

Я знайшов таке порівняння корисним:

str(f1) == str(f2)

У деяких випадках, коли ви можете впливати на подання вихідного номера, ви можете представляти їх у вигляді дробів замість плавців, використовуючи цілі чисельник та знаменник. Таким чином ви можете мати точні порівняння.

Детальніше див. Модуль « Фракція» .

Мені сподобалося пропозицію @Sesquipedal, але з модифікацією (особливий випадок використання, коли обидва значення 0 повертають помилково). У моєму випадку я був на Python 2.7 і просто використав просту функцію:

if f1 ==0 and f2 == 0:
    return True
else:
    return abs(f1-f2) < tol*max(abs(f1),abs(f2))

Корисно для випадку, коли ви хочете переконатися, що 2 числа однакові "до точності", не потрібно вказувати допуски:

• Знайдіть мінімальну точність двох чисел

• Округлить їх обох до мінімальної точності та порівняйте

def isclose(a,b):                                       
    astr=str(a)                                         
    aprec=len(astr.split('.')[1]) if '.' in astr else 0 
    bstr=str(b)                                         
    bprec=len(bstr.split('.')[1]) if '.' in bstr else 0 
    prec=min(aprec,bprec)                                      
    return round(a,prec)==round(b,prec)                               

Як написано, працює лише для чисел без 'e' у їх рядковому поданні (означає 0,9999999999995e-4 <число <= 0,9999999999995e11)

Приклад:

>>> isclose(10.0,10.049)
True
>>> isclose(10.0,10.05)
False

Для порівняння до заданої десяткової точки без atol/rtol:

def almost_equal(a, b, decimal=6):
    return '{0:.{1}f}'.format(a, decimal) == '{0:.{1}f}'.format(b, decimal)

print(almost_equal(0.0, 0.0001, decimal=5)) # False
print(almost_equal(0.0, 0.0001, decimal=4)) # True 

Це може бути трохи некрасивим злом, але він працює досить добре, коли вам не потрібно більше плавкої точності за замовчуванням (близько 11 десятків).

Функція round_to використовує метод форматування із вбудованого класу str для округлення поплавця до рядка, який представляє поплавок з необхідним числом десяткових знаків, а потім застосовує вбудовану функцію eval до закругленої поплавкової рядки для повернення до цифрового типу поплавця.

Функція is_close просто застосовує простий умовний характер для округлого поплавця.

def round_to(float_num, prec):
    return eval("'{:." + str(int(prec)) + "f}'.format(" + str(float_num) + ")")

def is_close(float_a, float_b, prec):
    if round_to(float_a, prec) == round_to(float_b, prec):
        return True
    return False

>>>a = 10.0
10.0
>>>b = 10.0001
10.0001
>>>print is_close(a, b, prec=3)
True
>>>print is_close(a, b, prec=4)
False

Оновлення:

Як запропонував @stepehjfox, більш чіткий спосіб побудувати функцію rount_to, уникаючи "eval", - це використання вкладеного форматування :

def round_to(float_num, prec):
    return '{:.{precision}f}'.format(float_num, precision=prec)

Дотримуючись тієї ж ідеї, код може бути ще простішим за допомогою нових чудових f-рядків (Python 3.6+):

def round_to(float_num, prec):
    return f'{float_num:.{prec}f}'

Таким чином, ми могли б навіть обернути все це однією простою і чистою функцією "is_close" :

def is_close(a, b, prec):
    return f'{a:.{prec}f}' == f'{b:.{prec}f}'

З точки зору абсолютної помилки ви можете просто перевірити

if abs(a - b) <= error:
    print("Almost equal")

Деякі відомості про те, чому float діє дивно в Python https://youtu.be/v4HhvoNLILk?t=1129

Ви також можете використовувати math.isclose для відносних помилок