ภาษาโปรแกรมสามารถทำอะไรได้บ้างเพื่อหลีกเลี่ยงข้อผิดพลาดที่เกิดจากการลอยตัว?

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

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

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

ดังนั้นเมื่อคุณพูด $ 1.23 นั่นเป็น 123 เซนต์จริง ๆ เสมอเสมอทำคณิตศาสตร์ของคุณในแง่เหล่านั้นและคุณจะไม่เป็นไร สำหรับข้อมูลเพิ่มเติมดู:

• รูปแบบปริมาณและเงินของ Martin Fowler
• รูปแบบหนังสือของเขาเกี่ยวกับสถาปัตยกรรมแอพพลิเคชั่นระดับองค์กรและรูปแบบการวิเคราะห์
• Wikipedia เกี่ยวกับการปัดเศษของธนาคาร

ตอบคำถามโดยตรงภาษาการเขียนโปรแกรมควรรวมประเภทเงินเป็นแบบดั้งเดิมที่เหมาะสม

ปรับปรุง

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

การสนับสนุนประเภททศนิยมช่วยได้ในหลายกรณี หลายภาษามีประเภททศนิยม แต่มีการใช้น้อยเกินไป

การทำความเข้าใจกับการประมาณที่เกิดขึ้นเมื่อทำงานกับการแสดงตัวเลขจริงเป็นสิ่งสำคัญ การใช้ทั้งทศนิยมและทศนิยมประเภท9 * (1/9) != 1คือคำสั่งที่ถูกต้อง เมื่อค่าคงที่เครื่องมือเพิ่มประสิทธิภาพอาจปรับการคำนวณให้เหมาะสมเพื่อให้ถูกต้อง

การให้บริการตัวดำเนินการโดยประมาณจะช่วยได้ อย่างไรก็ตามการเปรียบเทียบดังกล่าวเป็นปัญหา โปรดทราบว่า. 9999 ล้านล้านดอลลาร์มีค่าประมาณ 1 ล้านล้านดอลลาร์ คุณกรุณาฝากส่วนต่างในบัญชีธนาคารของฉันได้ไหม

เราได้รับการบอกว่าจะทำอย่างไรในปีแรก (ปีที่สอง) การบรรยายทางวิทยาการคอมพิวเตอร์เมื่อฉันไปมหาวิทยาลัย (หลักสูตรนี้เป็นวิชาบังคับก่อนสำหรับหลักสูตรวิทยาศาสตร์ส่วนใหญ่เช่นกัน)

ฉันจำได้ว่าอาจารย์พูดว่า "ตัวเลขจุดลอยตัวเป็นค่าประมาณใช้ประเภทจำนวนเต็มเพื่อเงินใช้ FORTRAN หรือภาษาอื่นด้วยหมายเลข BCD เพื่อการคำนวณที่แม่นยำ" (แล้วเขาก็ชี้ให้เห็นถึงการประมาณโดยใช้ตัวอย่างคลาสสิกของ 0.2 เป็นไปไม่ได้ที่จะแสดงอย่างถูกต้องในจุดลอยตัวไบนารี) สิ่งนี้ก็ปรากฏขึ้นในสัปดาห์นั้นในแบบฝึกหัดในห้องปฏิบัติการ

การบรรยายเดียวกัน: "หากคุณต้องได้รับความแม่นยำมากขึ้นจากจุดลอยตัวให้เรียงลำดับคำศัพท์ของคุณเพิ่มตัวเลขขนาดเล็กเข้าด้วยกันไม่ใช่ตัวเลขขนาดใหญ่" ที่ติดอยู่ในใจของฉัน

ไม่กี่ปีที่ผ่านมาฉันมีรูปทรงกลมบางอย่างที่จำเป็นต้องมีความแม่นยำมากและยังคงรวดเร็ว 80 บิตสองเท่าบนพีซีไม่ได้ตัดดังนั้นฉันจึงเพิ่มบางประเภทลงในโปรแกรมที่เรียงลำดับคำศัพท์ก่อนที่จะทำการดำเนินการสลับ แก้ไขปัญหา.

ก่อนที่คุณจะบ่นเกี่ยวกับคุณภาพของกีตาร์เรียนรู้การเล่น

ฉันมีเพื่อนร่วมงานสี่ปีที่แล้วที่ทำงานให้กับ JPL เขาแสดงความไม่เชื่อว่าเราใช้ FORTRAN สำหรับบางสิ่ง (เราต้องการแบบจำลองเชิงตัวเลขที่แม่นยำที่สุดคำนวณจากออฟไลน์) "เราแทนที่ FORTRAN ทั้งหมดด้วย C ++" เขากล่าวอย่างภาคภูมิใจ ฉันหยุดสงสัยว่าทำไมพวกเขาพลาดดาวเคราะห์

คำเตือน: จุดลอยตัวประเภทSystem.Doubleขาดความแม่นยำสำหรับการทดสอบความเท่าเทียมกันโดยตรง

double x = CalculateX();
if (x == 0.1)
{
    // ............
}

ฉันไม่เชื่อว่าทุกอย่างสามารถทำได้หรือควรจะทำในระดับภาษา

โดยค่าเริ่มต้นภาษาควรใช้การปันส่วนที่มีความแม่นยำโดยพลการสำหรับตัวเลขที่ไม่ใช่จำนวนเต็ม

ผู้ที่ต้องการเพิ่มประสิทธิภาพสามารถขอลอย ใช้พวกเขาเป็นค่าเริ่มต้นทำให้รู้สึกใน C และภาษาการเขียนโปรแกรมระบบอื่น ๆ แต่ไม่ได้รับความนิยมในภาษาส่วนใหญ่ในวันนี้

ปัญหาที่ใหญ่ที่สุดสองปัญหาที่เกี่ยวข้องกับหมายเลขจุดลอยตัวคือ:

• หน่วยที่ไม่สอดคล้องกันที่นำไปใช้กับการคำนวณ (โปรดทราบว่าสิ่งนี้มีผลกระทบต่อเลขคณิตเลขจำนวนเต็มในลักษณะเดียวกัน)
• ความล้มเหลวในการทำความเข้าใจว่าหมายเลข FP นั้นเป็นการประมาณและวิธีการปัดเศษอย่างชาญฉลาด

ประเภทแรกของความล้มเหลวสามารถแก้ไขได้โดยการจัดให้มีประเภทคอมโพสิตที่มีค่าและข้อมูลหน่วย ตัวอย่างเช่น a lengthหรือareaค่าที่รวมหน่วย (เมตรหรือตารางเมตรหรือฟุตและตารางฟุตตามลำดับ) มิฉะนั้นคุณจะต้องขยันหมั่นเพียรในการทำงานกับหน่วยวัดชนิดหนึ่งเสมอและแปลงเป็นหน่วยอื่นเมื่อเราแบ่งปันคำตอบกับมนุษย์

ประเภทที่สองของความล้มเหลวคือความล้มเหลวของแนวคิด ความล้มเหลวปรากฏตัวเมื่อมีคนคิดว่าพวกเขาเป็นตัวเลขที่แน่นอน มันส่งผลกระทบต่อการดำเนินงานที่เท่าเทียมกันข้อผิดพลาดในการปัดเศษสะสม ฯลฯ ตัวอย่างเช่นอาจเป็นเรื่องที่ถูกต้องสำหรับการวัดหนึ่งระบบสองระบบที่เทียบเท่ากันภายในระยะขอบที่ผิดพลาด นั่นคือ. 999 และ 1.001 นั้นเท่ากับ 1.0 เมื่อคุณไม่สนใจความแตกต่างที่เล็กกว่า +/- .1 อย่างไรก็ตามไม่ใช่ว่าทุกระบบจะผ่อนปรน

หากมีสิ่งอำนวยความสะดวกระดับภาษาใด ๆ ที่จำเป็นแล้วฉันจะเรียกมันว่าความเสมอภาคความแม่นยำ ใน NUnit, JUnit และเฟรมเวิร์กการทดสอบที่สร้างขึ้นในทำนองเดียวกันคุณสามารถควบคุมความแม่นยำที่ถือว่าถูกต้อง ตัวอย่างเช่น:

Assert.That(.999, Is.EqualTo(1.001).Within(10).Percent);
// -- or --
Assert.That(.999, Is.EqualTo(1.001).Within(.1));

ตัวอย่างเช่นหาก C # หรือ Java ถูกดัดแปลงให้มีตัวดำเนินการที่มีความแม่นยำอาจมีลักษณะดังนี้:

if(.999 == 1.001 within .1) { /* do something */ }

อย่างไรก็ตามหากคุณให้คุณสมบัติเช่นนั้นคุณต้องพิจารณากรณีที่ความเท่าเทียมกันนั้นดีถ้าด้าน +/- ไม่เหมือนกัน ตัวอย่างเช่น + 1 / -10 จะพิจารณาตัวเลขสองตัวที่เทียบเท่ากันหากหนึ่งในนั้นอยู่ในระยะที่มากกว่า 1 หรือ 10 น้อยกว่าหมายเลขแรก ในการจัดการกรณีนี้คุณอาจต้องเพิ่มrangeคำหลักด้วย:

if(.999 == 1.001 within range(.001, -.1)) { /* do something */ }

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

โปรแกรมเมอร์ยังคงต้องทำงานกับภาษาและเข้าใจว่ามันจัดการกับจุดลอยตัวได้อย่างไรเพราะถ้าไม่มีพวกมันจะทำการตั้งสมมติฐานและวันหนึ่งพฤติกรรมที่ถูกจารึกไว้จะไม่ตรงกับสมมติฐานของพวกเขา

สิ่งที่โปรแกรมเมอร์ต้องการรู้:

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

ภาษาการเขียนโปรแกรมสามารถทำอะไรได้บ้างเพื่อหลีกเลี่ยงข้อผิดพลาด [floating point] ... ?

ใช้ค่าเริ่มต้นที่สมเหตุสมผลเช่นการรองรับการถอดรหัสในตัว

Groovy ทำสิ่งนี้ได้เป็นอย่างดีถึงแม้จะมีความพยายามอยู่บ้างคุณก็ยังสามารถเขียนโค้ดเพื่อแนะนำจุดที่ไม่แน่นอนได้

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

ไม่เคยสนใจจุดลอย เราต้องเข้าใจว่ารูปแบบบิตครึ่งหนึ่งนั้นใช้สำหรับจำนวนลบและที่ 2 ^ 64 มีขนาดค่อนข้างเล็กเพื่อหลีกเลี่ยงปัญหาทั่วไปเกี่ยวกับเลขคณิตจำนวนเต็ม

สิ่งหนึ่งที่ภาษาสามารถทำได้ - ลบการเปรียบเทียบความเท่าเทียมกันจากประเภทจุดลอยอื่น ๆ นอกเหนือจากการเปรียบเทียบโดยตรงกับค่า NAN

การทดสอบความเท่าเทียมกันจะมีอยู่ก็ต่อเมื่อการเรียกใช้ฟังก์ชันที่ใช้ค่าสองค่าและเดลตาหรือสำหรับภาษาเช่น C # ที่อนุญาตให้ประเภทมีวิธีการ EqualsTo ที่ใช้ค่าอื่นและเดลต้า

ฉันคิดว่ามันแปลกที่ไม่มีใครชี้เคล็ดลับจำนวนตรรกยะของตระกูล Lisp

เปิด sbcl อย่างจริงจังและทำสิ่งนี้: (+ 1 3)แล้วคุณจะได้ 4. ถ้า*( 3 2)คุณได้ 6 คุณได้ลอง(/ 5 3)แล้วคุณจะได้ 5/3 หรือ 5 ใน 5

สิ่งนี้น่าจะช่วยได้บ้างในบางสถานการณ์ใช่ไหม

สิ่งหนึ่งที่ผมอยากจะเห็นจะได้รับการยอมรับว่าdoubleจะfloatควรจะได้รับการยกย่องว่าเป็นแปลงขยับขยายในขณะfloatที่จะdoubleมีการกวดขัน (*) ที่อาจดูเหมือนเคาน์เตอร์ง่าย แต่พิจารณาประเภทที่จริงหมายถึง:

• 0.1f หมายถึง "13,421,773.5 / 134,217,728 บวกหรือลบ 1 / 268,435,456 หรือมากกว่านั้น"
• 0.1 หมายถึงจริงๆ 3,602,879,701,896,397 / 36,028,797,018,963,968 บวกหรือลบ 1 / 72,057,594,037,927,936 หรือประมาณ "

หากหนึ่งมีdoubleที่ถือเป็นตัวแทนที่ดีที่สุดของปริมาณ "หนึ่งในสิบ" และแปลงfloatเป็นผลลัพธ์จะเป็น "13,421,773.5 / 134,217,728 บวกหรือลบ 1 / 268,435,456 หรือซึ่งเป็นคำอธิบายที่ถูกต้องของค่า

ในทางตรงกันข้ามหากมีสิ่งfloatใดที่มีตัวแทนที่ดีที่สุดของปริมาณ "หนึ่งในสิบ" และแปลงdoubleเป็นผลลัพธ์จะเป็น "13,421,773.5 / 134,217,728 บวกหรือลบ 1 / 72,057,594,037,927,936 หรือนัยอื่น ๆ " - ระดับความแม่นยำโดยนัย ซึ่งผิดโดยมีปัจจัยมากกว่า 53 ล้าน

แม้ว่ามาตรฐาน IEEE-744 กำหนดให้ต้องดำเนินการทางคณิตศาสตร์แบบเลขทศนิยมเนื่องจากเลขทศนิยมทุกตัวจะแสดงปริมาณตัวเลขที่แน่นอนที่กึ่งกลางของช่วงนั้นอย่างแม่นยำ แต่ไม่ควรนำมาใช้เพื่อบ่งบอกว่าค่าจุดลอยตัวเป็นตัวแทนของความถูกต้องแน่นอน ปริมาณเชิงตัวเลข แต่ความต้องการที่ค่าจะถือว่าเป็นศูนย์กลางของช่วงของพวกเขาเกิดขึ้นจากข้อเท็จจริงสามประการ: (1) การคำนวณจะต้องดำเนินการราวกับว่าตัวถูกดำเนินการมีค่าที่แม่นยำเฉพาะบางอย่าง; (2) สมมติฐานที่สอดคล้องและมีเอกสารเป็นประโยชน์มากกว่าสมมติฐานที่ไม่สอดคล้องกันหรือไม่มีเอกสาร (3) ถ้ามีใครจะทำให้สมมติฐานที่สอดคล้องกันไม่มีสมมติฐานที่สอดคล้องกันอื่น ๆ จะดีกว่าสมมติว่าปริมาณหมายถึงจุดศูนย์กลางของช่วง

ฉันจำได้เมื่อ 25 ปีที่แล้วบางคนคิดแพ็กเกจตัวเลขสำหรับ C ซึ่งใช้ "range range" ซึ่งแต่ละอันประกอบด้วย 128-bit float; การคำนวณทั้งหมดจะทำในลักษณะที่จะคำนวณค่าต่ำสุดและสูงสุดที่เป็นไปได้สำหรับแต่ละผลลัพธ์ หากทำการคำนวณซ้ำขนาดใหญ่เป็นเวลานานและมีค่าเป็น [12.53401391134 12.53902812673] ก็สามารถมั่นใจได้ว่าในขณะที่ความแม่นยำจำนวนมากหายไปจากข้อผิดพลาดในการปัดเศษผลลัพธ์จะยังคงแสดงได้อย่างสมเหตุสมผลเท่ากับ 12.54 (และเป็น ' 12.9 หรือ 53.2) ฉันประหลาดใจที่ฉันไม่ได้เห็นการสนับสนุนประเภทดังกล่าวในภาษากระแสหลักใด ๆ โดยเฉพาะอย่างยิ่งเนื่องจากพวกเขาดูเหมือนจะเหมาะสมกับหน่วยคณิตศาสตร์ที่สามารถทำงานกับค่าหลายค่าในแบบคู่ขนาน

(*) ในทางปฏิบัติมักจะมีประโยชน์ในการใช้ค่าความแม่นยำสองเท่าเพื่อเก็บการคำนวณระดับกลางเมื่อทำงานกับตัวเลขที่มีความแม่นยำเดียวดังนั้นการใช้ typecast สำหรับการดำเนินการทั้งหมดอาจน่ารำคาญ ภาษาสามารถช่วยได้ด้วยการพิมพ์ "fuzzy double" ซึ่งจะทำการคำนวณเป็นสองเท่าและสามารถส่งไปและกลับจากเดี่ยวได้อย่างอิสระ สิ่งนี้จะเป็นประโยชน์อย่างยิ่งหากฟังก์ชันที่รับพารามิเตอร์ประเภทdoubleและการส่งคืนdoubleสามารถทำเครื่องหมายเพื่อให้พวกเขาสร้างโอเวอร์โหลดที่ยอมรับและส่งคืน "fuzzy double" โดยอัตโนมัติแทน

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

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

• ภาษามีการสนับสนุนประเภททศนิยม แน่นอนว่าสิ่งนี้ไม่ได้แก้ปัญหาจริงๆ แต่คุณก็ยังไม่มีตัวแทนที่แน่นอนและแน่นอนเช่น⅓;
• ฐานข้อมูลและกรอบงานบางประเภทได้รับการสนับสนุนประเภทเงินซึ่งโดยทั่วไปจะเก็บจำนวนเซ็นต์เป็นจำนวนเต็ม
• มีห้องสมุดบางแห่งสำหรับการสนับสนุนจำนวนตรรกยะ ที่แก้ปัญหาของ⅓ แต่ไม่ได้แก้ปัญหาตัวอย่างเช่น√2;

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

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

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

Finance.importEstimate(float value, Finance roundingStep)

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

บางสิ่งที่อาจช่วยได้:

• ฉันจะสองคนที่ถามว่า "ทำไมการทดสอบความเท่าเทียมกันที่แน่นอนสำหรับจุดลอยตัวนั้นถูกกฎหมาย?"
• ให้ใช้isNear()ฟังก์ชั่นแทน
• จัดเตรียมและสนับสนุนการใช้วัตถุตัวสะสมแบบลอยตัว (ซึ่งเพิ่มลำดับของค่าจุดลอยตัวที่เสถียรมากกว่าเพียงแค่เพิ่มพวกมันทั้งหมดลงในตัวแปรจุดลอยตัวปกติ)

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