เป็นวิธีที่ดีที่สุดในการเปรียบเทียบลอยสำหรับความเท่าเทียมกันเกือบในงูหลามคืออะไร?

เป็นที่ทราบกันดีว่าการเปรียบเทียบลอยเพื่อความเท่าเทียมนั้นมีปัญหาเล็กน้อยเนื่องจากปัญหาการปัดเศษและความแม่นยำ

ตัวอย่างเช่น: https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/

วิธีที่แนะนำในการจัดการกับสิ่งนี้ใน Python คืออะไร?

มีฟังก์ชั่นห้องสมุดมาตรฐานสำหรับที่นี่ไหม?

งูหลาม 3.5 เพิ่มmath.iscloseและcmath.iscloseฟังก์ชั่นที่อธิบายไว้ในPEP 485

หากคุณกำลังใช้รุ่นก่อนหน้าของงูหลาม, ฟังก์ชั่นเทียบเท่าจะได้รับในเอกสาร

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

ฉันยอมรับว่าคำตอบของ Gareth น่าจะเหมาะสมที่สุดกับฟังก์ชั่น / โซลูชันที่มีน้ำหนักเบา

แต่ฉันคิดว่ามันจะมีประโยชน์ที่จะทราบว่าถ้าคุณกำลังใช้ NumPy หรือกำลังพิจารณาอยู่มันมีฟังก์ชั่นแบบแพคเกจสำหรับสิ่งนี้

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

ข้อจำกัดความรับผิดชอบเล็กน้อย: การติดตั้ง NumPy อาจเป็นประสบการณ์ที่ไม่สำคัญขึ้นอยู่กับแพลตฟอร์มของคุณ

ใช้decimalโมดูลของ Python ซึ่งจัดเตรียมDecimalคลาส

จากความคิดเห็นที่:

เป็นที่น่าสังเกตว่าถ้าคุณกำลังทำคณิตศาสตร์หนักและคุณไม่ต้องการความแม่นยำจากทศนิยมนี่สามารถทำให้สิ่งต่าง ๆ ลงไปได้ ทุ่นลอยน้ำเป็นหนทางวิธีที่เร็วกว่าที่จะจัดการกับ แต่ไม่แน่ชัด ทศนิยมมีความแม่นยำมาก แต่ช้า

ฉันไม่ทราบว่ามีอะไรในห้องสมุดมาตรฐาน Python (หรือที่อื่น ๆ ) ที่ใช้งานAlmostEqual2sComplementฟังก์ชั่นของ Dawson หากนั่นเป็นพฤติกรรมที่คุณต้องการคุณจะต้องใช้มันด้วยตัวเอง (ซึ่งในกรณีนี้แทนที่จะใช้ดอว์สันแฮ็บิตฉลาดที่คุณต้องการอาจจะทำได้ดีกว่าที่จะใช้การทดสอบแบบดั้งเดิมมากขึ้นในรูปแบบif abs(a-b) <= eps1*(abs(a)+abs(b)) + eps2หรือคล้ายกันที่จะได้รับดอว์สันเหมือนพฤติกรรมคุณอาจจะบอกว่าสิ่งที่ต้องการ. if abs(a-b) <= eps*max(EPS,abs(a),abs(b))สำหรับบางขนาดเล็กคงEPSนี้ไม่ว่า เช่นเดียวกับดอว์สัน แต่มันก็เหมือนวิญญาณ

ภูมิปัญญาทั่วไปที่ตัวเลขทศนิยมไม่สามารถนำมาเปรียบเทียบเพื่อความเท่าเทียมกันได้ไม่ถูกต้อง จำนวนจุดลอยตัวไม่แตกต่างจากจำนวนเต็ม: ถ้าคุณประเมิน "a == b" คุณจะได้รับจริงถ้าพวกเขาเป็นตัวเลขที่เหมือนกันและเป็นเท็จอย่างอื่น (ด้วยความเข้าใจว่าแน่นอนว่า NaN สองตัวนั้นไม่เหมือนกัน)

ปัญหาที่แท้จริงคือ: ถ้าฉันทำการคำนวณบางอย่างแล้วและไม่แน่ใจว่าตัวเลขสองตัวที่ฉันต้องเปรียบเทียบนั้นถูกต้องตรงไหนแล้วอะไรล่ะ? ปัญหานี้เหมือนกันสำหรับเลขทศนิยมเนื่องจากเป็นจำนวนเต็ม หากคุณประเมินค่านิพจน์จำนวนเต็ม "7/3 * 3" จะไม่เปรียบเทียบเท่ากับ "7 * 3/3"

สมมติว่าเราถามว่า "ฉันจะเปรียบเทียบจำนวนเต็มกับความเท่าเทียมได้อย่างไร" ในสถานการณ์เช่นนี้ ไม่มีคำตอบเดียว; สิ่งที่คุณควรทำขึ้นอยู่กับสถานการณ์ที่เฉพาะเจาะจงโดยเฉพาะอย่างยิ่งข้อผิดพลาดที่คุณมีและสิ่งที่คุณต้องการบรรลุ

นี่เป็นตัวเลือกที่เป็นไปได้

หากคุณต้องการได้ผลลัพธ์ที่ "จริง" หากตัวเลขที่แน่นอนทางคณิตศาสตร์จะเท่ากันคุณอาจลองใช้คุณสมบัติของการคำนวณที่คุณดำเนินการเพื่อพิสูจน์ว่าคุณได้รับข้อผิดพลาดเดียวกันในสองตัวเลข หากเป็นไปได้และคุณเปรียบเทียบสองตัวเลขที่เป็นผลมาจากนิพจน์ที่จะให้ตัวเลขที่เท่ากันหากคำนวณให้ถูกต้องคุณจะได้รับ "ความจริง" จากการเปรียบเทียบ อีกวิธีหนึ่งคือคุณอาจวิเคราะห์คุณสมบัติของการคำนวณและพิสูจน์ว่าข้อผิดพลาดไม่เกินจำนวนที่แน่นอนบางทีอาจเป็นจำนวนที่แน่นอนหรือจำนวนที่สัมพันธ์กับหนึ่งในอินพุตหรือหนึ่งในเอาต์พุต ในกรณีดังกล่าวคุณสามารถถามได้ว่าตัวเลขที่คำนวณสองตัวนั้นแตกต่างกันตามจำนวนเงินนั้นมากที่สุดหรือไม่และส่งคืน "จริง" หากอยู่ภายในช่วงเวลานั้น หากคุณไม่สามารถพิสูจน์ข้อผิดพลาดได้ คุณอาจคาดเดาและหวังในสิ่งที่ดีที่สุด วิธีหนึ่งในการคาดเดาคือการประเมินตัวอย่างสุ่มจำนวนมากและดูการกระจายที่คุณได้รับในผลลัพธ์

แน่นอนเนื่องจากเราตั้งข้อกำหนดที่คุณจะได้รับ "จริง" เท่านั้นหากผลลัพธ์ที่แน่นอนทางคณิตศาสตร์เท่ากันเราจึงเปิดโอกาสที่คุณจะได้รับ "จริง" แม้ว่าพวกเขาจะไม่เท่ากัน (อันที่จริงแล้วเราสามารถตอบสนองความต้องการโดยการส่งกลับ "จริง" เสมอซึ่งทำให้การคำนวณง่าย แต่โดยทั่วไปไม่พึงประสงค์ดังนั้นฉันจะหารือเกี่ยวกับการปรับปรุงสถานการณ์ด้านล่าง)

หากคุณต้องการได้ผลลัพธ์ที่ "ผิดพลาด" หากตัวเลขที่แน่นอนทางคณิตศาสตร์นั้นไม่เท่ากันคุณต้องพิสูจน์ว่าการประเมินตัวเลขของคุณให้ตัวเลขที่แตกต่างกันหากตัวเลขที่แน่นอนทางคณิตศาสตร์นั้นไม่เท่ากัน สิ่งนี้อาจเป็นไปไม่ได้สำหรับการใช้งานจริงในสถานการณ์ทั่วไปมากมาย ดังนั้นให้เราพิจารณาทางเลือกอื่น

ข้อกำหนดที่มีประโยชน์อาจเป็นได้ว่าเราได้ผลลัพธ์เป็น "เท็จ" หากตัวเลขที่แน่นอนทางคณิตศาสตร์แตกต่างกันมากกว่าจำนวนที่แน่นอน ตัวอย่างเช่นเราอาจจะคำนวณว่าลูกบอลถูกโยนในเกมคอมพิวเตอร์ที่เดินทางไปหรือไม่และเราต้องการทราบว่าลูกบอลดังกล่าวกระทบหรือไม่ ในกรณีนี้เราต้องการได้รับ "จริง" อย่างแน่นอนหากลูกบอลกระทบกับค้างคาวและเราต้องการได้รับ "เท็จ" ถ้าลูกบอลอยู่ไกลจากค้างคาวและเราสามารถยอมรับคำตอบที่ "ไม่จริง" ถ้าลูกบอลใน การจำลองที่แม่นยำทางคณิตศาสตร์พลาดการตีไม้ แต่อยู่ในระยะมิลลิเมตรของการตีไม้ตี ในกรณีนี้เราต้องพิสูจน์ (หรือคาดเดา / ประมาณ) ว่าการคำนวณตำแหน่งลูกบอลและตำแหน่งค้างคาวของเรามีข้อผิดพลาดรวมกันอย่างน้อยหนึ่งมิลลิเมตร (สำหรับตำแหน่งที่สนใจทั้งหมด) สิ่งนี้จะทำให้เรากลับมาเสมอ "

ดังนั้นวิธีที่คุณตัดสินใจว่าจะกลับมาอย่างไรเมื่อเปรียบเทียบจำนวนจุดลอยตัวนั้นขึ้นอยู่กับสถานการณ์ของคุณเป็นอย่างมาก

สำหรับวิธีการพิสูจน์ขอบเขตข้อผิดพลาดในการคำนวณซึ่งอาจเป็นเรื่องที่ซับซ้อน การนำไปใช้งานแบบ floating-point ใด ๆ ที่ใช้มาตรฐาน IEEE 754 ในโหมดการปัดเศษไปยังที่ใกล้ที่สุดจะส่งกลับตัวเลข floating-point ที่ใกล้เคียงกับผลลัพธ์ที่แน่นอนที่สุดสำหรับการดำเนินการพื้นฐานใด ๆ (โดยเฉพาะการคูณการหารการบวกการลบรากที่สอง) (ในกรณีที่มีความเสมอกันให้ปัดเศษให้มีค่าบิตต่ำ) (โปรดระมัดระวังเป็นพิเศษเกี่ยวกับสแควร์รูทและการหารการใช้ภาษาของคุณอาจใช้วิธีที่ไม่สอดคล้องกับมาตรฐาน 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 มันแตกต่างจากหนึ่งซับของ Mark Ransom คือมันสามารถจัดการ "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 ตัวนั้นเหมือนกัน 'ถึงความแม่นยำ' ไม่จำเป็นต้องระบุความอดทน:

• ค้นหาความแม่นยำขั้นต่ำของตัวเลข 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 <number <= 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-stringsใหม่ที่ยอดเยี่ยม(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")

ข้อมูลบางอย่างเกี่ยวกับสาเหตุที่ทลอยกระทำผิดแปลกใน Python https://youtu.be/v4HhvoNLILk?t=1129

คุณยังสามารถใช้math.iscloseสำหรับข้อผิดพลาดที่เกี่ยวข้อง