Apa cara terbaik untuk membandingkan pelampung untuk hampir-kesetaraan dalam Python?

Sudah diketahui bahwa membandingkan floats untuk persamaan adalah sedikit rumit karena masalah pembulatan dan ketepatan.

Misalnya: https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/

Apa cara yang disarankan untuk menangani hal ini dengan Python?

Tentunya ada fungsi perpustakaan standar untuk ini di suatu tempat?

Python 3.5 menambahkan math.isclosedan cmath.isclosefungsinya seperti dijelaskan dalam PEP 485 .

Jika Anda menggunakan versi Python sebelumnya, fungsi yang setara diberikan dalam dokumentasi .

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_toladalah toleransi relatif, itu dikalikan dengan semakin besar besarnya dua argumen; karena nilainya semakin besar, begitu pula perbedaan yang diizinkan di antara mereka sambil tetap menganggapnya sama.

abs_toladalah toleransi mutlak yang diterapkan apa adanya dalam semua kasus. Jika perbedaannya kurang dari toleransi tersebut, nilainya dianggap sama.

Apakah sesederhana yang berikut ini tidak cukup baik?

return abs(f1 - f2) <= allowed_error

Saya setuju bahwa jawaban Gareth mungkin paling tepat sebagai fungsi / solusi ringan.

Tapi saya pikir akan sangat membantu untuk dicatat bahwa jika Anda menggunakan NumPy atau sedang mempertimbangkannya, ada fungsi yang dikemas untuk ini.

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

Namun sedikit penafian: menginstal NumPy bisa menjadi pengalaman yang tidak sepele tergantung pada platform Anda.

Gunakan decimalmodul Python , yang menyediakan Decimalkelas.

Dari komentar:

Perlu dicatat bahwa jika Anda melakukan pekerjaan matematika-berat dan Anda tidak benar-benar membutuhkan ketelitian dari desimal, ini dapat benar-benar menghambat semuanya. Mengapung adalah cara, cara yang lebih cepat untuk dihadapi, tetapi tidak tepat. Desimal sangat tepat tetapi lambat.

Saya tidak mengetahui apa pun di pustaka standar Python (atau di tempat lain) yang mengimplementasikan AlmostEqual2sComplementfungsi Dawson . Jika itu jenis perilaku yang Anda inginkan, Anda harus menerapkannya sendiri. (Dalam hal ini, daripada menggunakan retas bitwise Dawson yang cerdik, Anda mungkin akan lebih baik menggunakan tes yang lebih konvensional dari bentuk if abs(a-b) <= eps1*(abs(a)+abs(b)) + eps2atau sejenisnya. Untuk mendapatkan perilaku seperti Dawson, Anda mungkin mengatakan sesuatu seperti if abs(a-b) <= eps*max(EPS,abs(a),abs(b))untuk beberapa perbaikan kecil EPS; ini bukan tepatnya sama seperti Dawson, tetapi memiliki semangat yang serupa.

Kebijaksanaan umum bahwa angka floating-point tidak dapat dibandingkan untuk kesetaraan adalah tidak akurat. Bilangan floating-point tidak berbeda dari bilangan bulat: Jika Anda mengevaluasi "a == b", Anda akan menjadi kenyataan jika bilangan itu identik dan salah (dengan pengertian bahwa dua NaN tentu saja bukan bilangan identik).

Masalah sebenarnya adalah ini: Jika saya telah melakukan perhitungan dan tidak yakin dua angka yang harus saya bandingkan benar, lalu apa? Masalah ini sama untuk floating-point seperti halnya untuk bilangan bulat. Jika Anda mengevaluasi ekspresi integer "7/3 * 3", itu tidak akan sama dengan "7 * 3/3".

Jadi misalkan kita bertanya, "Bagaimana cara membandingkan bilangan bulat untuk kesetaraan?" dalam situasi seperti itu. Tidak ada jawaban tunggal; apa yang harus Anda lakukan tergantung pada situasi spesifik, terutama kesalahan apa yang Anda miliki dan apa yang ingin Anda capai.

Berikut beberapa pilihan yang mungkin.

Jika Anda ingin mendapatkan hasil "benar" jika angka yang tepat secara matematis akan sama, maka Anda dapat mencoba menggunakan properti dari perhitungan yang Anda lakukan untuk membuktikan bahwa Anda mendapatkan kesalahan yang sama dalam dua angka. Jika itu layak, dan Anda membandingkan dua angka yang dihasilkan dari ekspresi yang akan memberikan angka yang sama jika dihitung secara tepat, maka Anda akan mendapatkan "benar" dari perbandingan. Pendekatan lain adalah bahwa Anda dapat menganalisis properti perhitungan dan membuktikan bahwa kesalahan tidak pernah melebihi jumlah tertentu, mungkin jumlah absolut atau jumlah relatif terhadap salah satu input atau salah satu output. Dalam hal ini, Anda dapat bertanya apakah dua angka yang dihitung berbeda paling banyak jumlah itu, dan mengembalikan "benar" jika mereka berada dalam interval. Jika Anda tidak dapat membuktikan kesalahan terikat, Anda mungkin menebak dan berharap untuk yang terbaik. Salah satu cara menebak adalah dengan mengevaluasi banyak sampel acak dan melihat jenis distribusi yang Anda dapatkan dalam hasil.

Tentu saja, karena kami hanya menetapkan persyaratan bahwa Anda mendapatkan "benar" jika hasil yang tepat secara matematis sama, kami membiarkan kemungkinan bahwa Anda mendapatkan "benar" walaupun tidak sama. (Faktanya, kita dapat memenuhi persyaratan dengan selalu mengembalikan "benar". Ini membuat perhitungannya sederhana tetapi umumnya tidak diinginkan, jadi saya akan membahas memperbaiki situasi di bawah ini.)

Jika Anda ingin mendapatkan hasil "false" jika angka yang tepat secara matematis tidak sama, Anda perlu membuktikan bahwa evaluasi Anda terhadap angka menghasilkan angka yang berbeda jika angka yang tepat secara matematis tidak sama. Ini mungkin mustahil untuk tujuan praktis dalam banyak situasi umum. Jadi mari kita pertimbangkan alternatifnya.

Persyaratan yang berguna mungkin bahwa kita mendapatkan hasil "salah" jika angka yang tepat secara matematis berbeda lebih dari jumlah tertentu. Sebagai contoh, mungkin kita akan menghitung di mana bola dilemparkan dalam permainan komputer bepergian, dan kami ingin tahu apakah itu memukul kelelawar. Dalam hal ini, kami tentu ingin mendapatkan "benar" jika bola memukul kelelawar, dan kami ingin mendapatkan "salah" jika bola jauh dari kelelawar, dan kami dapat menerima jawaban "benar" yang salah jika bola masuk simulasi matematis yang tepat melewatkan kelelawar tetapi dalam milimeter memukul kelelawar. Dalam hal itu, kita perlu membuktikan (atau menebak / memperkirakan) bahwa perhitungan kita tentang posisi bola dan posisi kelelawar memiliki kesalahan gabungan paling banyak satu milimeter (untuk semua posisi yang menarik). Ini akan memungkinkan kita untuk selalu kembali "

Jadi, bagaimana Anda memutuskan apa yang akan dikembalikan ketika membandingkan angka floating-point sangat tergantung pada situasi spesifik Anda.

Mengenai cara Anda membuktikan batas kesalahan untuk perhitungan, itu bisa menjadi subjek yang rumit. Setiap implementasi floating-point menggunakan standar IEEE 754 dalam mode round-to-terdekat mengembalikan angka floating-point terdekat dengan hasil yang tepat untuk setiap operasi dasar (terutama perkalian, pembagian, penambahan, pengurangan, akar kuadrat). (Dalam kasus seri, bulat sehingga bit rendahnya genap.) (Berhati-hatilah tentang akar kuadrat dan pembagian; implementasi bahasa Anda mungkin menggunakan metode yang tidak sesuai dengan IEEE 754 untuk itu.) Karena persyaratan ini, kita tahu kesalahan dalam hasil tunggal paling banyak 1/2 dari nilai bit paling signifikan. (Jika lebih, pembulatan akan pergi ke nomor yang berbeda yaitu dalam 1/2 nilai.)

Pergi dari sana menjadi jauh lebih rumit; langkah selanjutnya adalah melakukan operasi di mana salah satu input sudah memiliki beberapa kesalahan. Untuk ekspresi sederhana, kesalahan ini dapat diikuti melalui perhitungan untuk mencapai batas kesalahan akhir. Dalam praktiknya, ini hanya dilakukan dalam beberapa situasi, seperti mengerjakan perpustakaan matematika berkualitas tinggi. Dan, tentu saja, Anda perlu kontrol yang tepat atas operasi yang dilakukan. Bahasa tingkat tinggi sering memberi kompiler banyak kelonggaran, jadi Anda mungkin tidak tahu di mana operasi urutan dilakukan.

Ada banyak lagi yang bisa (dan) ditulis tentang topik ini, tetapi saya harus berhenti di situ. Singkatnya, jawabannya adalah: Tidak ada rutinitas perpustakaan untuk perbandingan ini karena tidak ada solusi tunggal yang sesuai dengan sebagian besar kebutuhan yang layak dimasukkan ke dalam rutinitas perpustakaan. (Jika membandingkan dengan interval kesalahan relatif atau absolut sudah mencukupi untuk Anda, Anda dapat melakukannya hanya tanpa rutin perpustakaan.)

Jika Anda ingin menggunakannya dalam konteks pengujian / TDD, saya akan mengatakan ini adalah cara standar:

from nose.tools import assert_almost_equals

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

math.isclose () telah ditambahkan ke Python 3.5 untuk itu ( kode sumber ). Ini adalah port-nya untuk Python 2. Perbedaannya dari One-liner dari Mark Ransom adalah ia dapat menangani "inf" dan "-inf" dengan benar.

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

Saya menemukan perbandingan berikut bermanfaat:

str(f1) == str(f2)

Untuk beberapa kasus di mana Anda dapat memengaruhi representasi nomor sumber, Anda bisa merepresentasikannya sebagai fraksi alih-alih mengapung, menggunakan pembilang bilangan bulat dan penyebut. Dengan begitu Anda dapat memiliki perbandingan yang tepat.

Lihat Fraksi dari fraksi modul untuk rincian.

Saya menyukai saran @Sesquipedal tetapi dengan modifikasi (kasus penggunaan khusus ketika kedua nilai 0 mengembalikan False). Dalam kasus saya, saya menggunakan Python 2.7 dan hanya menggunakan fungsi sederhana:

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

Berguna untuk kasus di mana Anda ingin memastikan 2 angka sama 'hingga presisi', tidak perlu menentukan toleransi:

• Temukan presisi minimum dari 2 angka

• Bulat keduanya hingga presisi minimum dan bandingkan

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)                               

Seperti yang ditulis, hanya berfungsi untuk angka tanpa 'e' dalam representasi string mereka (artinya 0,9999999999995e-4 <angka <= 0,9999999999995e11)

Contoh:

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

Untuk membandingkan hingga desimal yang diberikan tanpa 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 

Ini mungkin hack yang agak jelek, tetapi ini bekerja cukup baik ketika Anda tidak membutuhkan lebih dari presisi float default (sekitar 11 desimal).

Fungsi round_to menggunakan metode format dari kelas str bawaan untuk mengumpulkan float menjadi string yang mewakili float dengan jumlah desimal yang diperlukan, dan kemudian menerapkan fungsi built-in eval ke string float bulat untuk kembali. ke tipe numerik float.

Fungsi is_close hanya menerapkan persyaratan sederhana untuk float yang dibulatkan ke atas.

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

Memperbarui:

Seperti yang disarankan oleh @stepehjfox, cara yang lebih bersih untuk membangun fungsi rount_to menghindari "eval" menggunakan pemformatan bersarang :

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

Mengikuti ide yang sama, kode ini bahkan bisa lebih sederhana menggunakan f-string baru yang hebat (Python 3.6+):

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

Jadi, kita bahkan bisa membungkusnya semua dalam satu fungsi 'is_close' yang sederhana dan bersih :

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

Dalam hal kesalahan absolut, Anda bisa mengeceknya

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

Beberapa informasi tentang mengapa float bertindak aneh dengan Python https://youtu.be/v4HhvoNLILk?t=1129

Anda juga dapat menggunakan math.isclose untuk kesalahan relatif