การตรวจสอบค่าทศนิยมเพื่อความเท่าเทียมกันเป็น 0 ปลอดภัยหรือไม่

ฉันรู้ว่าคุณไม่สามารถพึ่งพาความเท่าเทียมกันระหว่างค่าประเภทสองหรือทศนิยมได้ตามปกติ แต่ฉันสงสัยว่า 0 เป็นกรณีพิเศษหรือไม่

ในขณะที่ฉันสามารถเข้าใจความไม่ตรงระหว่าง 0.00000000000001 ถึง 0.00000000000002 แต่ 0 นั้นดูเหมือนจะค่อนข้างยากที่จะสับสนเนื่องจากไม่มีอะไรเลย หากคุณไม่เข้าใจอะไรเลยมันก็ไม่ใช่อะไรอีกแล้ว

แต่ฉันไม่รู้เกี่ยวกับหัวข้อนี้มากนักจึงไม่เหมาะที่จะพูด

double x = 0.0;
return (x == 0.0) ? true : false;

จะกลับมาจริงหรือไม่?

มันเป็นความปลอดภัยที่จะคาดหวังว่าการเปรียบเทียบจะกลับมาtrueและถ้าหากตัวแปรคู่มีค่าตรง0.0(ซึ่งในตัวอย่างรหัสต้นฉบับของคุณเป็นของแน่นอนกรณี) สิ่งนี้สอดคล้องกับความหมายของตัว==ดำเนินการ a == bหมายถึง " aเท่ากับb"

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

หากคุณจำเป็นต้องทำการเปรียบเทียบ "ความเท่าเทียมกัน" จำนวนมากคุณควรเขียนฟังก์ชันตัวช่วยเล็ก ๆ น้อย ๆ หรือวิธีการขยายใน. NET 3.5 เพื่อเปรียบเทียบ:

public static bool AlmostEquals(this double double1, double double2, double precision)
{
    return (Math.Abs(double1 - double2) <= precision);
}

สามารถใช้วิธีต่อไปนี้:

double d1 = 10.0 * .1;
bool equals = d1.AlmostEquals(0.0, 0.0000001);

สำหรับตัวอย่างง่ายๆของคุณการทดสอบนั้นใช้ได้ แต่สิ่งนี้:

bool b = ( 10.0 * .1 - 1.0 == 0.0 );

โปรดจำไว้ว่า. 1 เป็นทศนิยมซ้ำในไบนารีและไม่สามารถแทนค่าได้อย่างแน่นอน จากนั้นเปรียบเทียบกับรหัสนี้:

double d1 = 10.0 * .1; // make sure the compiler hasn't optimized the .1 issue away
bool b = ( d1 - 1.0 == 0.0 );

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

จากรายการ MSDN สำหรับDouble.Equals :

ความแม่นยำในการเปรียบเทียบ

ควรใช้เมธอด Equals ด้วยความระมัดระวังเนื่องจากค่าที่เท่ากันสองค่าอาจไม่เท่ากันเนื่องจากความแม่นยำที่แตกต่างกันของทั้งสองค่า ตัวอย่างต่อไปนี้รายงานว่าค่า Double .3333 และค่า Double ที่ส่งกลับโดยการหาร 1 ด้วย 3 นั้นไม่เท่ากัน

...

แทนที่จะเปรียบเทียบเพื่อความเท่าเทียมเทคนิคหนึ่งที่แนะนำเกี่ยวข้องกับการกำหนดส่วนต่างของค่าที่ยอมรับได้ระหว่างค่าสองค่า (เช่น. 01% ของค่าใดค่าหนึ่ง) หากค่าสัมบูรณ์ของความแตกต่างระหว่างค่าทั้งสองน้อยกว่าหรือเท่ากับระยะขอบนั้นความแตกต่างน่าจะเกิดจากความแตกต่างในด้านความแม่นยำดังนั้นค่าจึงน่าจะเท่ากัน ตัวอย่างต่อไปนี้ใช้เทคนิคนี้เพื่อเปรียบเทียบ. 33333 และ 1/3 ค่า Double สองค่าที่ตัวอย่างโค้ดก่อนหน้าพบว่าไม่เท่ากัน

ยังดูDouble.Epsilon

ปัญหาเกิดขึ้นเมื่อคุณเปรียบเทียบการใช้ค่าทศนิยมประเภทต่างๆเช่นการเปรียบเทียบ float กับ double แต่ถ้าเป็นประเภทเดียวกันก็ไม่น่ามีปัญหา

float f = 0.1F;
bool b1 = (f == 0.1); //returns false
bool b2 = (f == 0.1F); //returns true

ปัญหาคือบางครั้งโปรแกรมเมอร์ลืมไปว่าการร่ายประเภทโดยนัย (double to float) กำลังเกิดขึ้นสำหรับการเปรียบเทียบและส่งผลให้เกิดข้อผิดพลาด

หากตัวเลขถูกกำหนดโดยตรงให้กับโฟลต์หรือสองเท่าก็ปลอดภัยที่จะทดสอบกับศูนย์หรือจำนวนเต็มใด ๆ ที่สามารถแสดงเป็น 53 บิตสำหรับสองเท่าหรือ 24 บิตสำหรับโฟลต

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

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

ไม่มันไม่ตกลง ที่เรียกว่าค่า denormalized (ค่าปกติ) เมื่อเทียบกับ 0.0 จะเปรียบเทียบเป็นเท็จ (ไม่ใช่ศูนย์) แต่เมื่อใช้ในสมการจะถูกทำให้เป็นมาตรฐาน (กลายเป็น 0.0) ดังนั้นการใช้สิ่งนี้เป็นกลไกเพื่อหลีกเลี่ยงการหารด้วยศูนย์จึงไม่ปลอดภัย ให้เพิ่ม 1.0 และเปรียบเทียบกับ 1.0 แทน สิ่งนี้จะช่วยให้มั่นใจได้ว่า subnormals ทั้งหมดถือเป็นศูนย์

ลองสิ่งนี้แล้วคุณจะพบว่า == ไม่น่าเชื่อถือสำหรับ double / float
double d = 0.1 + 0.2; bool b = d == 0.3;

นี่คือคำตอบจาก Quora

อันที่จริงฉันคิดว่าควรใช้รหัสต่อไปนี้เพื่อเปรียบเทียบค่าสองเท่ากับ 0.0:

double x = 0.0;
return (Math.Abs(x) < double.Epsilon) ? true : false;

เหมือนกันสำหรับลอย:

float x = 0.0f;
return (Math.Abs(x) < float.Epsilon) ? true : false;