Jaki jest najlepszy sposób porównania pływaków dla prawie równości w Pythonie?

Powszechnie wiadomo, że porównywanie liczb zmiennoprzecinkowych w celu zapewnienia równości jest trochę kłopotliwe z powodu problemów z zaokrąglaniem i precyzją.

Na przykład: https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/

Jaki jest zalecany sposób radzenia sobie z tym w Pythonie?

Na pewno jest gdzieś standardowa funkcja biblioteki?

Python 3.5 dodaje funkcje math.iscloseicmath.isclose zgodnie z opisem w PEP 485 .

Jeśli używasz wcześniejszej wersji Pythona, równoważna funkcja jest podana w dokumentacji .

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_toljest względną tolerancją, pomnożoną przez większą z wielkości dwóch argumentów; wraz ze wzrostem wartości rośnie dozwolona różnica między nimi, jednocześnie uznając je za równe.

abs_toljest bezwzględną tolerancją, którą stosuje się w obecnej postaci we wszystkich przypadkach. Jeśli różnica jest mniejsza niż jedna z tych tolerancji, wartości są uważane za równe.

Czy coś tak prostego jak poniższe nie jest wystarczająco dobre?

return abs(f1 - f2) <= allowed_error

Zgadzam się, że odpowiedź Garetha jest prawdopodobnie najbardziej odpowiednia jako lekka funkcja / rozwiązanie.

Pomyślałem jednak, że przydałoby się zauważyć, że jeśli używasz NumPy lub zastanawiasz się nad tym, istnieje do tego funkcja spakowana.

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

Małe zastrzeżenie: instalacja NumPy może być łatwym doświadczeniem w zależności od platformy.

Użyj decimalmodułu Pythona , który udostępnia Decimalklasę.

Z komentarzy:

Warto zauważyć, że jeśli wykonujesz ciężką pracę matematyczną i nie potrzebujesz absolutnie precyzji od dziesiętnej, może to naprawdę zapaść się w rzeczy. Spławiki są znacznie szybsze, ale nieprecyzyjne. Dziesiętne są niezwykle precyzyjne, ale powolne.

Nie znam niczego w standardowej bibliotece Pythona (ani gdzie indziej), która implementuje AlmostEqual2sComplementfunkcję Dawsona . Jeśli chcesz tego rodzaju zachowanie, musisz je wdrożyć samodzielnie. (W takim przypadku, zamiast używać sprytnych bitowych hacków Dawsona, prawdopodobnie lepiej byłoby użyć bardziej konwencjonalnych testów formularza if abs(a-b) <= eps1*(abs(a)+abs(b)) + eps2lub podobnego. Aby uzyskać zachowanie podobne do Dawsona, możesz powiedzieć coś if abs(a-b) <= eps*max(EPS,abs(a),abs(b))w stylu małej poprawki EPS; to nie jest dokładnie tak samo jak Dawson, ale ma podobny duch.

Powszechna mądrość, że liczb zmiennoprzecinkowych nie można porównywać dla równości, jest niedokładna. Liczby zmiennoprzecinkowe nie różnią się od liczb całkowitych: Jeśli ocenisz „a == b”, otrzymasz prawdę, jeśli są to liczby identyczne, a fałsz w przeciwnym razie (przy założeniu, że dwa NaN nie są oczywiście liczbami identycznymi).

Rzeczywisty problem jest następujący: jeśli wykonałem kilka obliczeń i nie jestem pewien, czy dwie liczby, które muszę porównać, są dokładnie poprawne, to co? Ten problem jest taki sam dla liczb zmiennoprzecinkowych, jak dla liczb całkowitych. Jeśli ocenisz wyrażenie całkowite „7/3 * 3”, nie będzie ono porównywane z „7 * 3/3”.

Załóżmy więc, że zapytaliśmy „Jak porównać liczby całkowite w celu zapewnienia równości?” w takiej sytuacji. Nie ma jednej odpowiedzi; to, co powinieneś zrobić, zależy od konkretnej sytuacji, w szczególności od rodzaju błędów i tego, co chcesz osiągnąć.

Oto kilka możliwych opcji.

Jeśli chcesz uzyskać „prawdziwy” wynik, jeśli matematycznie dokładne liczby byłyby równe, możesz spróbować użyć właściwości obliczeń, które wykonujesz, aby udowodnić, że otrzymujesz te same błędy w tych dwóch liczbach. Jeśli jest to wykonalne, a porównasz dwie liczby, które wynikają z wyrażeń, które dałyby równe liczby, jeśli zostałyby dokładnie obliczone, uzyskasz „prawdziwość” z porównania. Inne podejście polega na tym, że możesz przeanalizować właściwości obliczeń i udowodnić, że błąd nigdy nie przekracza określonej kwoty, być może kwoty bezwzględnej lub kwoty odnoszącej się do jednego z danych wejściowych lub jednego z danych wyjściowych. W takim przypadku możesz zapytać, czy dwie obliczone liczby różnią się co najwyżej o tę kwotę, i zwrócić „prawda”, jeśli mieszczą się w przedziale. Jeśli nie możesz udowodnić błędu, możesz zgadywać i mieć nadzieję na najlepsze. Jednym ze sposobów zgadywania jest ocena wielu losowych próbek i sprawdzenie, jaki rozkład otrzymujesz w wynikach.

Oczywiście, ponieważ ustaliliśmy wymóg, abyś był „prawdziwy”, jeśli matematycznie dokładne wyniki są równe, pozostawiliśmy otwartą możliwość, abyś był „prawdziwy”, nawet jeśli są nierówne. (W rzeczywistości możemy spełnić ten wymóg, zawsze zwracając „prawda”. To sprawia, że ​​obliczenia są proste, ale generalnie niepożądane, dlatego omówię poprawę sytuacji poniżej.)

Jeśli chcesz uzyskać „fałszywy” wynik, jeśli matematyczne dokładne liczby byłyby nierówne, musisz udowodnić, że twoja ocena liczb daje różne liczby, jeśli matematyczne dokładne liczby byłyby nierówne. Może to być niemożliwe ze względów praktycznych w wielu typowych sytuacjach. Rozważmy więc alternatywę.

Przydatnym wymogiem może być uzyskanie „fałszywego” wyniku, jeśli matematyczne dokładne liczby różnią się o więcej niż pewną liczbę. Na przykład być może obliczymy, gdzie wędrowała piłka rzucona w grę komputerową, i chcemy wiedzieć, czy uderzyła w nietoperza. W tym przypadku z pewnością chcemy uzyskać „prawdziwą”, jeśli piłka uderzy w nietoperza, a także „fałszywą”, jeśli piłka jest daleko od nietoperza, i możemy zaakceptować niepoprawną „prawdziwą” odpowiedź, jeśli piłka matematycznie dokładna symulacja nie trafiła nietoperza, ale znajduje się w odległości milimetra od uderzenia nietoperza. W takim przypadku musimy udowodnić (lub zgadnąć / oszacować), że nasze obliczenia pozycji piłki i pozycji nietoperza mają łączny błąd co najwyżej jednego milimetra (dla wszystkich pozycji zainteresowania). To pozwoli nam zawsze wracać ”

To, jak zdecydujesz, co zwrócić, porównując liczby zmiennoprzecinkowe, zależy w dużej mierze od konkretnej sytuacji.

Jeśli chodzi o sprawdzanie granic błędów w obliczeniach, może to być skomplikowany temat. Każda implementacja zmiennoprzecinkowa wykorzystująca standard IEEE 754 w trybie zaokrąglania do najbliższego zwraca liczbę zmiennoprzecinkową najbliższą dokładnemu wynikowi dla dowolnej podstawowej operacji (w szczególności mnożenie, dzielenie, dodawanie, odejmowanie, pierwiastek kwadratowy). (W przypadku remisu, zaokrąglenia, tak więc niski bit jest parzysty.) (Zachowaj szczególną ostrożność przy pierwiastku kwadratowym i dzieleniu; twoja implementacja języka może używać metod, które nie są zgodne z IEEE 754). Z tego powodu wiemy, że błąd w pojedynczym wyniku wynosi najwyżej 1/2 wartości najmniej znaczącego bitu. (Gdyby było więcej, zaokrąglenie byłoby ustawione na inną liczbę, która mieści się w zakresie 1/2 wartości.)

Dalsza praca staje się znacznie bardziej skomplikowana; następnym krokiem jest wykonanie operacji, w której jedno z wejść ma już jakiś błąd. W przypadku prostych wyrażeń błędy te można śledzić przez obliczenia, aby osiągnąć granicę błędu końcowego. W praktyce odbywa się to tylko w kilku sytuacjach, takich jak praca nad wysokiej jakości biblioteką matematyczną. I oczywiście potrzebujesz dokładnej kontroli dokładnie nad tym, które operacje są wykonywane. Języki wysokiego poziomu często dają kompilatorowi dużo luzu, więc możesz nie wiedzieć, w jakiej kolejności są wykonywane operacje.

Jest o wiele więcej, co można napisać (i jest) na ten temat, ale muszę się na tym zatrzymać. Podsumowując, odpowiedź brzmi: nie ma procedury bibliotecznej dla tego porównania, ponieważ nie ma jednego rozwiązania, które byłoby w stanie zaspokoić większość potrzeb, które byłoby warte zastosowania w bibliotece. (Jeśli porównanie z przedziałem błędu względnego lub bezwzględnego wystarcza, możesz to zrobić po prostu bez procedury bibliotecznej).

Jeśli chcesz używać go w kontekście testowania / TDD, powiedziałbym, że jest to standardowy sposób:

from nose.tools import assert_almost_equals

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

math.isclose () został w tym celu dodany do Pythona 3.5 ( kod źródłowy ). Oto jego port dla Pythona 2. Różnica w stosunku do jednowierszowej Mark Ransom polega na tym, że może on poprawnie obsługiwać „inf” i „-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

Pomocne okazało się następujące porównanie:

str(f1) == str(f2)

W niektórych przypadkach, w których możesz wpłynąć na reprezentację numeru źródłowego, możesz przedstawić je jako ułamki zamiast liczb zmiennoprzecinkowych, używając liczb całkowitych i mianowników. W ten sposób możesz mieć dokładne porównania.

Aby uzyskać szczegółowe informacje, zobacz Moduł Frakcja z ułamków.

Podobała mi się sugestia @Sesquipedal, ale z modyfikacją (specjalny przypadek użycia, gdy obie wartości wynoszą 0, zwraca False). W moim przypadku korzystałem z Pythona 2.7 i użyłem prostej funkcji:

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

Przydatne w przypadku, gdy chcesz się upewnić, że 2 liczby są takie same „do precyzji”, nie musisz określać tolerancji:

• Znajdź minimalną precyzję 2 liczb

• Zaokrąglij oba z nich do minimalnej precyzji i porównaj

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)                               

Jak napisano, działa tylko dla liczb bez „e” w ich reprezentacji ciągu (co oznacza 0,9999999999995e-4 <liczba <= 0,9999999999995e11)

Przykład:

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

Aby porównać do podanego miejsca po przecinku bez 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 

To może być trochę brzydki hack, ale działa całkiem dobrze, gdy nie potrzebujesz więcej niż domyślna precyzja float (około 11 miejsc po przecinku).

Funkcja round_to używa metody formatowania z wbudowanej klasy str, aby zaokrąglić liczbę zmiennoprzecinkową do ciągu, który reprezentuje liczbę zmiennoprzecinkową z wymaganą liczbą miejsc po przecinku, a następnie stosuje wbudowaną funkcję eval do zaokrąglonego ciągu zmiennoprzecinkowego, aby wrócić na zmiennoprzecinkowy typ liczbowy.

Funkcja is_close stosuje prosty warunek do zaokrąglonej liczby zmiennoprzecinkowej.

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

Aktualizacja:

Jak sugeruje @stepehjfox, czystszym sposobem na zbudowanie funkcji rount_to unikającej „eval” jest użycie zagnieżdżonego formatowania :

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

Zgodnie z tym samym pomysłem kod może być jeszcze prostszy przy użyciu świetnych nowych ciągów F (Python 3.6+):

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

Moglibyśmy nawet wszystko to zawrzeć w jednej prostej i czystej funkcji „is_close” :

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

Jeśli chodzi o błąd bezwzględny, możesz po prostu sprawdzić

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

Niektóre informacje o tym, dlaczego float działa tak dziwnie w Pythonie https://youtu.be/v4HhvoNLILk?t=1129

Możesz także użyć math.isclose do względnych błędów