ทำไม NaN - NaN == 0.0 กับ Intel C ++ Compiler

เป็นที่ทราบกันดีว่า NaNs เผยแพร่เลขคณิต แต่ฉันไม่พบการสาธิตดังนั้นฉันจึงเขียนการทดสอบเล็กน้อย:

#include <limits>
#include <cstdio>

int main(int argc, char* argv[]) {
    float qNaN = std::numeric_limits<float>::quiet_NaN();

    float neg = -qNaN;

    float sub1 = 6.0f - qNaN;
    float sub2 = qNaN - 6.0f;
    float sub3 = qNaN - qNaN;

    float add1 = 6.0f + qNaN;
    float add2 = qNaN + qNaN;

    float div1 = 6.0f / qNaN;
    float div2 = qNaN / 6.0f;
    float div3 = qNaN / qNaN;

    float mul1 = 6.0f * qNaN;
    float mul2 = qNaN * qNaN;

    printf(
        "neg: %f\nsub: %f %f %f\nadd: %f %f\ndiv: %f %f %f\nmul: %f %f\n",
        neg, sub1,sub2,sub3, add1,add2, div1,div2,div3, mul1,mul2
    );

    return 0;
}

ตัวอย่าง ( แสดงสดที่นี่ ) สร้างสิ่งที่ฉันคาดหวัง (เชิงลบค่อนข้างแปลก แต่มันก็สมเหตุสมผล):

neg: -nan
sub: nan nan nan
add: nan nan
div: nan nan nan
mul: nan nan

MSVC 2015 ผลิตสิ่งที่คล้ายกัน อย่างไรก็ตาม Intel C ++ 15 ผลิต:

neg: -nan(ind)
sub: nan nan 0.000000
add: nan nan
div: nan nan nan
mul: nan nan

โดยเฉพาะ, qNaN - qNaN == 0.0.

นี่ ... ไม่ถูกต้องใช่ไหม มาตรฐานที่เกี่ยวข้อง (ISO C, ISO C ++, IEEE 754) พูดถึงอะไรและทำไมจึงมีพฤติกรรมที่แตกต่างกันระหว่างคอมไพเลอร์?

จัดการใน Intel C ++ คอมไพเลอร์ลอยจุดเริ่มต้นคือ/fp:fastที่จับNaN's unsafely (ซึ่งยังผลในการNaN == NaNเป็นtrueตัวอย่าง) ลองระบุ/fp:strictหรือ/fp:preciseดูว่ามีประโยชน์หรือไม่

นี้ . . . ไม่ถูกใช่มั้ย คำถามของฉัน: มาตรฐานที่เกี่ยวข้อง (ISO C, ISO C ++, IEEE 754) พูดถึงอะไรได้บ้าง

Petr Abdulin ตอบแล้วทำไมคอมไพเลอร์ให้0.0คำตอบ

นี่คือสิ่งที่ IEEE-754: 2008 พูดว่า:

(6.2 Operations with NaNs) "[... ] สำหรับการดำเนินการที่มีอินพุต NaN แบบเงียบนอกเหนือไปจากการดำเนินการขั้นสูงสุดและขั้นต่ำหากผลลัพธ์จุดลอยตัวถูกส่งมอบผลลัพธ์จะเป็น NaN ที่เงียบซึ่งควรเป็นหนึ่งใน ใส่ NaN "

ดังนั้นผลลัพธ์ที่ถูกต้องเพียงอย่างเดียวสำหรับการลบตัวถูกดำเนินการ NaN สองตัวที่เงียบสงบคือตัวย่อที่เงียบ ผลลัพธ์อื่นใดไม่ถูกต้อง

The C Standard พูดว่า:

(C11, F.9.2 การแปลงนิพจน์ p1) "[... ]

x - x → 0. 0 "นิพจน์ x - x และ 0 0 ไม่เท่ากันถ้า x เป็น NaN หรืออนันต์"

(ที่นี่ NaN หมายถึงเงียบ NaN ตาม F.2.1p1 "ข้อมูลจำเพาะนี้ไม่ได้กำหนดพฤติกรรมของการส่งสัญญาณ NaNs โดยทั่วไปจะใช้คำว่า NaN เพื่อแสดง NaN ที่เงียบสงบ")

เมื่อฉันเห็นคำตอบที่เป็นไปตามมาตรฐานของคอมไพเลอร์ของ Intel และไม่มีใครพูดถึงเรื่องนี้ฉันจะชี้ให้เห็นว่าทั้ง GCC และ Clang มีโหมดที่พวกเขาทำสิ่งที่คล้ายกันมาก พฤติกรรมเริ่มต้นของพวกเขาเป็นไปตามมาตรฐาน IEEE -

$ g++ -O2 test.cc && ./a.out 
neg: -nan
sub: nan nan nan
add: nan nan
div: nan nan nan
mul: nan nan

$ clang++ -O2 test.cc && ./a.out 
neg: -nan
sub: -nan nan nan
add: nan nan
div: nan nan nan
mul: nan nan

- แต่ถ้าคุณขอความเร็วโดยใช้ความถูกต้องคุณจะได้สิ่งที่คุณขอ -

$ g++ -O2 -ffast-math test.cc && ./a.out 
neg: -nan
sub: nan nan 0.000000
add: nan nan
div: nan nan 1.000000
mul: nan nan

$ clang++ -O2 -ffast-math test.cc && ./a.out 
neg: -nan
sub: -nan nan 0.000000
add: nan nan
div: nan nan nan
mul: nan nan

ฉันคิดว่ามันยุติธรรมอย่างยิ่งที่จะวิจารณ์การเลือกค่าเริ่มต้นของ ICC แต่ฉันจะไม่อ่านสงคราม Unix ทั้งหมดกลับสู่การตัดสินใจ