คำถามติดแท็ก ieee-754

เป็นที่ทราบกันดีว่า 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 …

300 c++  c  floating-point  ieee-754  icc 

ทำไมการเปรียบเทียบค่า NaN จึงแตกต่างจากค่าอื่น ๆ ทั้งหมด นั่นคือการเปรียบเทียบทั้งหมดกับโอเปอเรเตอร์ ==, <=,> =, <,> โดยที่หนึ่งหรือทั้งสองค่าเป็น NaN จะส่งคืนค่าเท็จซึ่งตรงกันข้ามกับพฤติกรรมของค่าอื่น ๆ ทั้งหมด ฉันคิดว่าสิ่งนี้จะทำให้การคำนวณเชิงตัวเลขง่ายขึ้น แต่ฉันไม่สามารถหาเหตุผลที่ระบุไว้อย่างชัดเจนไม่ได้แม้แต่ในบันทึกการบรรยายเกี่ยวกับสถานะของ IEEE 754โดย Kahan ซึ่งกล่าวถึงการตัดสินใจออกแบบรายละเอียดอื่น ๆ พฤติกรรมเบี่ยงเบนนี้ทำให้เกิดปัญหาเมื่อทำการประมวลผลข้อมูลอย่างง่าย ตัวอย่างเช่นเมื่อเรียงลำดับรายการเรคคอร์ด wrt บางฟิลด์มูลค่าจริงในโปรแกรม C ฉันจำเป็นต้องเขียนรหัสพิเศษเพื่อจัดการ NaN เป็นองค์ประกอบสูงสุดมิฉะนั้นอัลกอริทึมการเรียงลำดับอาจกลายเป็นสับสน แก้ไข: คำตอบจนถึงทุกคนยืนยันว่ามันไม่มีความหมายในการเปรียบเทียบ NaNs ฉันเห็นด้วย แต่นั่นไม่ได้หมายความว่าคำตอบที่ถูกต้องเป็นเท็จ แต่จะเป็น Not-a-Boolean (NaB) ซึ่งโชคดีที่ไม่มีอยู่จริง ดังนั้นทางเลือกของการคืนค่าจริงหรือเท็จสำหรับการเปรียบเทียบอยู่ในมุมมองของฉันโดยพลการและสำหรับการประมวลผลข้อมูลทั่วไปมันจะมีประโยชน์ถ้ามันเป็นไปตามกฎหมายปกติ (reflexivity ของ ==, trichotomy ของ <, ==,>) ซึ่งพึ่งพากฎหมายเหล่านี้จะสับสน ดังนั้นฉันขอความได้เปรียบที่เป็นรูปธรรมของการละเมิดกฎหมายเหล่านี้ไม่ใช่เพียงการให้เหตุผลเชิงปรัชญา แก้ไข …

267 floating-point  comparison  nan  ieee-754  iec10967 

อะไรคือจำนวนเต็ม "ไม่ลอย" ที่ใหญ่ที่สุดที่สามารถเก็บไว้ใน IEEE 754 double type โดยไม่สูญเสียความแม่นยำ

225 types  floating-point  double  ieee-754 

ชนิดข้อมูลลอยเป็นจุดลอยตัว IEEE 754 32 บิตที่มีความแม่นยำเดียวและชนิดข้อมูลสองเท่าเป็นทศนิยมลอยตัว 64 บิต IEEE 754 ที่มีความแม่นยำสองระดับ มันหมายความว่าอะไร? และเมื่อใดฉันจึงควรใช้การลอยแทนการใช้สองเท่าหรือในทางกลับกัน

220 java  floating-point  double  ieee-754 

เพื่อความชัดเจนถ้าฉันใช้ภาษาที่ใช้ IEE 754 ลอยและฉันประกาศ: float f0 = 0.f; float f1 = 1.f; ... แล้วพิมพ์มันออกมาฉันจะได้ 0.0000 และ 1.0000 - แน่นอน แต่ IEEE 754 ไม่สามารถแสดงตัวเลขทั้งหมดตามเส้นจริงได้ ใกล้กับศูนย์ 'ช่องว่าง' มีขนาดเล็ก เมื่อคุณห่างออกไปช่องว่างก็ใหญ่ขึ้น ดังนั้นคำถามของฉันคือ: สำหรับ IEEE 754 float ซึ่งเป็นจำนวนเต็ม (ใกล้เคียงที่สุดเป็นศูนย์) ซึ่งไม่สามารถแสดงได้อย่างแน่นอน ตอนนี้ฉันแค่กังวลกับ 32- บิตลอยแม้ว่าฉันจะสนใจฟังคำตอบสำหรับ 64- บิตถ้ามีคนให้! ฉันคิดว่ามันจะง่ายเหมือนการคำนวณ 2 bits_of_mantissaและการเพิ่ม 1 โดยที่bits_of_mantissaคือจำนวนบิตมาตรฐานที่เปิดเผย ฉันทำสิ่งนี้สำหรับ 32- บิตลอยบนเครื่องของฉัน (MSVC ++, …

162 types  floating-point  ieee-754 

ฉันรู้ว่าทศนิยมส่วนใหญ่ไม่ได้เป็นตัวแทนลอยจุดที่แน่นอน ( ลอยคณิตศาสตร์จุดเสีย? ) แต่ฉันไม่เห็นสาเหตุที่4*0.1พิมพ์ออกมาเป็นอย่างดี0.4แต่3*0.1ไม่ใช่เมื่อค่าทั้งสองมีการแสดงทศนิยมที่น่าเกลียด: >>> 3*0.1 0.30000000000000004 >>> 4*0.1 0.4 >>> from decimal import Decimal >>> Decimal(3*0.1) Decimal('0.3000000000000000444089209850062616169452667236328125') >>> Decimal(4*0.1) Decimal('0.40000000000000002220446049250313080847263336181640625')

158 python  floating-point  rounding  floating-accuracy  ieee-754 

ไม่นี่ไม่ใช่คำถาม"ทำไมจึงเป็น (1 / 3.0) * 3! = 1" ฉันได้อ่านเกี่ยวกับคะแนนจำนวนมากเมื่อเร็ว ๆ นี้; วิธีการคำนวณเดียวกันอาจให้ผลลัพธ์ที่แตกต่างกันในการตั้งค่าสถาปัตยกรรมหรือการเพิ่มประสิทธิภาพที่แตกต่างกัน นี่เป็นปัญหาสำหรับวิดีโอเกมที่เก็บรีเพลย์หรือเครือข่ายเพียร์ทูเพียร์ (ตรงข้ามกับเซิร์ฟเวอร์ - ไคลเอนต์) ซึ่งพึ่งพาลูกค้าทั้งหมดที่สร้างผลลัพธ์เดียวกันทุกครั้งที่รันโปรแกรม - ความคลาดเคลื่อนเล็กน้อยในหนึ่งเดียว การคำนวณ floating-point สามารถนำไปสู่สถานะเกมที่แตกต่างกันอย่างมากบนเครื่องที่แตกต่างกัน (หรือแม้แต่ในเครื่องเดียวกัน! ) นี้เกิดขึ้นแม้กระทั่งในหมู่ประมวลผลว่า "ตาม" มาตรฐาน IEEE-754หลักเพราะบางหน่วยประมวลผล (คือ x86) ใช้ความแม่นยำขยายคู่ นั่นคือพวกเขาใช้การลงทะเบียน 80 บิตเพื่อทำการคำนวณทั้งหมดจากนั้นตัดเป็น 64- บิตหรือ 32 บิตซึ่งนำไปสู่ผลลัพธ์การปัดเศษที่แตกต่างกันกว่าเครื่องที่ใช้ 64- บิตหรือ 32- บิตสำหรับการคำนวณ ฉันเห็นวิธีแก้ไขปัญหาออนไลน์หลายวิธี แต่ทั้งหมดสำหรับ C ++ ไม่ใช่ C #: ปิดใช้งานโหมดขยายความแม่นยำสองเท่า …

155 c#  .net  floating-point  precision  ieee-754 

เป็นไปได้ไหมที่จะหารด้วย 0 (หรืออินฟินิตี้) ในตัวอย่างต่อไปนี้ public double calculation(double a, double b) { if (a == b) { return 0; } else { return 2 / (a - b); } } ในกรณีปกติจะไม่แน่นอน แต่สิ่งที่ถ้าaและbมีความใกล้ชิดสามารถ(a-b)ส่งผลในการเป็น0เนื่องจากความแม่นยำของการคำนวณ? โปรดทราบว่าคำถามนี้ใช้สำหรับ Java แต่ฉันคิดว่ามันจะใช้ได้กับภาษาโปรแกรมส่วนใหญ่

131 floating-point  double  floating-accuracy  ieee-754 

PHP มีชื่อเสียงในด้านการเล่นกลประเภทต่างๆ ฉันต้องยอมรับว่ามันทำให้ฉันสับสนและฉันมีช่วงเวลาที่ยากลำบากในการค้นหาสิ่งที่เป็นตรรกะ / พื้นฐานพื้นฐานในการเปรียบเทียบ ตัวอย่างเช่นหาก$a > $bเป็นความจริงและ$b > $cเป็นความจริงก็ต้องหมายความว่า$a > $cเป็นเสมอจริงเกินไป? ตามตรรกะพื้นฐานฉันจะตอบว่าใช่แต่ฉันงงว่าฉันไม่เชื่อใจ PHP ในเรื่องนี้ อาจจะมีคนยกตัวอย่างที่ไม่ใช่กรณีนี้? นอกจากนี้ฉันยังสงสัยด้วยตัวดำเนินการที่เข้มงวดน้อยกว่าและเข้มงวดมากขึ้น (เนื่องจากความหมายของพวกเขาถูกอธิบายอย่างเคร่งครัดซึ่งฉันรู้ในอดีตจากการเปรียบเทียบความเท่าเทียมกันเท่านั้น) ว่ามันสร้างความแตกต่างใด ๆ หากสลับตัวถูกดำเนินการซ้ายและขวาด้วย ค่าไม่เท่ากันอย่างเคร่งครัด: # Precondition: if ($a === $b) { throw new Exception( 'Both are strictly equal - can not compare strictly for greater or smaller' ); } ($a > $b) …

115 php  if-statement  comparison  logic  ieee-754 

ฉันได้อ่านเกี่ยวกับจุดลอยตัวและฉันเข้าใจว่า NaN อาจเป็นผลมาจากการดำเนินการ แต่ฉันไม่เข้าใจว่านี่คือแนวคิดอะไรกันแน่ อะไรคือความแตกต่างระหว่างพวกเขา? สิ่งใดที่สามารถผลิตได้ในระหว่างการเขียนโปรแกรม C ++ ในฐานะโปรแกรมเมอร์ฉันสามารถเขียนโปรแกรมที่ทำให้เกิด sNaN ได้หรือไม่

108 floating-point  nan  ieee-754 

>>> (float('inf')+0j)*1 (inf+nanj) ทำไม? สิ่งนี้ทำให้เกิดข้อบกพร่องที่น่ารังเกียจในรหัสของฉัน เหตุใดจึงไม่1ระบุตัวตนแบบทวีคูณการให้(inf + 0j)?

97 python  nan  ieee-754 

ใน JavaScript ค่า NaN สามารถแสดงได้ด้วยช่วงกว้างของ 64- บิตคู่ภายใน โดยเฉพาะคู่ใด ๆ ที่มีการแสดง bitwise ต่อไปนี้ x111 1111 1111 xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx ถูกตีความว่าเป็น NaN คำถามของฉันคือ: สมมติว่าฉันส่ง uints 32 บิตสองตัวไปยังหมายเลข JS โดยใช้ ArrayBuffers ส่งผ่านไปมาแล้วโยนกลับไปที่ uints 32 บิตสองตัว บิตที่กู้คืนจะเหมือนเดิมหรือเป็นเอ็นจิน JS ที่อนุญาตให้เปลี่ยนบิตของ NaN ตามใจชอบหรือไม่ กล่าวอีกนัยหนึ่งสามารถใช้หมายเลข JS เพื่อเก็บ …

12 javascript  ieee-754