คำถามติดแท็ก floating-point

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

18
การจัดรูปแบบลอยโดยไม่มีศูนย์ต่อท้าย
ฉันจะจัดรูปแบบการลอยเพื่อไม่ให้มีศูนย์ต่อท้ายได้อย่างไร กล่าวอีกนัยหนึ่งฉันต้องการให้สตริงผลลัพธ์สั้นที่สุดเท่าที่จะทำได้ ตัวอย่างเช่น: 3 -> "3" 3. -> "3" 3.0 -> "3" 3.1 -> "3.1" 3.14 -> "3.14" 3.140 -> "3.14"


1
วิธีที่รวดเร็วในการปัด double เป็น 32-bit int อธิบาย
เมื่ออ่านLua ของรหัสที่มาผมสังเกตเห็นว่า Lua ใช้macroในการออกรอบdoubleกับ int32 ฉันดึงข้อมูลmacroและดูเหมือนว่า: union i_cast {double d; int i[2]}; #define double2int(i, d, t) \ {volatile union i_cast u; u.d = (d) + 6755399441055744.0; \ (i) = (t)u.i[ENDIANLOC];} ที่นี่ENDIANLOCถูกกำหนดให้เป็นendianness , 0สำหรับ endian เล็ก ๆ น้อย ๆ1สำหรับ endian ใหญ่ Lua จัดการกับ endianness อย่างระมัดระวัง tย่อมาจากชนิดจำนวนเต็มเช่นหรือintunsigned int ฉันทำวิจัยเล็กน้อยและมีรูปแบบที่ง่ายกว่าmacroซึ่งใช้ความคิดเดียวกัน: #define double2int(i, d) …

11
อะไรคือความแตกต่างระหว่างการดำเนินการจุดเดียวที่มีความแม่นยำและความแม่นยำสองเท่า
อะไรคือความแตกต่างระหว่างการดำเนินการจุดที่มีความแม่นยำเดียวและการดำเนินการที่มีความแม่นยำสองเท่า ฉันสนใจโดยเฉพาะอย่างยิ่งในแง่การปฏิบัติที่เกี่ยวข้องกับเครื่องเล่นวิดีโอเกม ตัวอย่างเช่น Nintendo 64 มีตัวประมวลผล 64 บิตหรือไม่และหากเป็นเช่นนั้นหมายความว่าสามารถดำเนินการกับจุดที่มีความแม่นยำสูงได้หรือไม่ PS3 และ Xbox 360 สามารถดึงการดำเนินการจุดลอยตัวที่มีความแม่นยำสองเท่าหรือเฉพาะความแม่นยำเพียงอย่างเดียวและโดยทั่วไปแล้วคือความสามารถในการใช้ความแม่นยำสองเท่าที่มีการใช้งาน (หากมีอยู่)

6
ถ้าฉันคัดลอกทุ่นไปยังตัวแปรอื่นพวกมันจะเท่ากันหรือไม่?
ฉันรู้ว่าการใช้==เพื่อตรวจสอบความเท่าเทียมกันของตัวแปร floating-point นั้นไม่ใช่วิธีที่ดี แต่ฉันแค่อยากรู้ว่าด้วยคำสั่งต่อไปนี้: float x = ... float y = x; assert(y == x) ตั้งแต่yคัดลอกมาจากxการยืนยันจะเป็นจริงหรือไม่

2
ซึ่งเป็นจำนวนเต็มแรกที่ IEEE 754 float ไม่สามารถแสดงได้อย่างแน่นอน
เพื่อความชัดเจนถ้าฉันใช้ภาษาที่ใช้ 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 ++, …

5
จัดรูปแบบ / ระงับสัญลักษณ์ทางวิทยาศาสตร์จาก Python Pandas Aggregation Results
หนึ่งสามารถปรับเปลี่ยนรูปแบบสำหรับการส่งออกจากการดำเนินงาน groupby ในแพนด้าที่ผลิตสัญกรณ์ทางวิทยาศาสตร์สำหรับจำนวนมาก? ฉันรู้วิธีการจัดรูปแบบสตริงในไพ ธ อน แต่ฉันรู้สึกแย่เมื่อพูดถึงการประยุกต์ใช้ที่นี่ df1.groupby('dept')['data1'].sum() dept value1 1.192433e+08 value2 1.293066e+08 value3 1.077142e+08 นี่เป็นการยับยั้งสัญกรณ์วิทยาศาสตร์ถ้าฉันแปลงเป็นสตริง แต่ตอนนี้ฉันแค่สงสัยว่าจะจัดรูปแบบสตริงและเพิ่มทศนิยมได้อย่างไร sum_sales_dept.astype(str)

4
ทำไมค่าทศนิยมของ 4 * 0.1 ดูดีใน Python 3 แต่ 3 * 0.1 ไม่ได้?
ฉันรู้ว่าทศนิยมส่วนใหญ่ไม่ได้เป็นตัวแทนลอยจุดที่แน่นอน ( ลอยคณิตศาสตร์จุดเสีย? ) แต่ฉันไม่เห็นสาเหตุที่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')

6
เหตุใด Double.MIN_VALUE จึงไม่ติดลบ
ทุกคนสามารถให้ความกระจ่างเกี่ยวกับสาเหตุที่Double.MIN_VALUEไม่จริงค่าต่ำสุดที่เป็นสองเท่าสามารถใช้? มันเป็นค่าบวกและแน่นอนว่า Double กระป๋องนั้นจะเป็นค่าลบ ฉันเข้าใจว่าทำไมมันเป็นจำนวนที่มีประโยชน์ แต่ดูเหมือนว่าชื่อ unintuitive Integer.MIN_VALUEมากโดยเฉพาะเมื่อเทียบกับ การโทรหามันDouble.SMALLEST_POSITIVEหรือMIN_INCREMENTคล้ายกันจะมีความหมายชัดเจนกว่า นอกจากนี้ค่าต่ำสุดที่ Doubles สามารถรับได้คือเท่าใด มันคือ-Double.MAX_VALUEอะไร เอกสารดูเหมือนจะไม่พูด

16
เปรียบเทียบลอยใน php
ฉันต้องการเปรียบเทียบสองโฟลตใน PHP เหมือนในโค้ดตัวอย่างนี้: $a = 0.17; $b = 1 - 0.83; //0.17 if($a == $b ){ echo 'a and b are same'; } else { echo 'a and b are not same'; } ในรหัสนี้จะส่งคืนผลลัพธ์ของelseเงื่อนไขแทนifเงื่อนไขแม้ว่า$aและ$bจะเหมือนกัน มีวิธีพิเศษในการจัดการ / เปรียบเทียบลอยใน PHP หรือไม่ ถ้าใช่โปรดช่วยฉันแก้ปัญหานี้ด้วย หรือมีปัญหากับการกำหนดค่าเซิร์ฟเวอร์ของฉัน?

17
จะเปรียบเทียบตัวเลขทศนิยมสองตัวใน Bash ได้อย่างไร
ฉันพยายามอย่างหนักเพื่อเปรียบเทียบตัวเลขทศนิยมสองจำนวนภายในสคริปต์ทุบตี ฉันต้องเปลี่ยนตัวแปรเช่น let num1=3.17648e-22 let num2=1.5 ตอนนี้ฉันแค่ต้องการเปรียบเทียบตัวเลขสองตัวนี้ง่ายๆ: st=`echo "$num1 < $num2" | bc` if [ $st -eq 1]; then echo -e "$num1 < $num2" else echo -e "$num1 >= $num2" fi น่าเสียดายที่ฉันมีปัญหากับการใช้ num1 ที่เหมาะสมซึ่งอาจเป็น "รูปแบบ e" :( ความช่วยเหลือใด ๆ คำแนะนำยินดีต้อนรับ!

9
ทำไม Double.NaN == Double.NaN ส่งคืนค่าเท็จ
ฉันเพิ่งศึกษาคำถาม OCPJP และฉันพบรหัสแปลก ๆ นี้: public static void main(String a[]) { System.out.println(Double.NaN==Double.NaN); System.out.println(Double.NaN!=Double.NaN); } เมื่อฉันรันรหัสฉันได้รับ: false true เอาต์พุตfalseเมื่อเราเปรียบเทียบสองสิ่งที่ดูเหมือนกันหรือไม่ อะไรNaNหมายถึง?
155 java  floating-point  nan  scjp  ocpjp 

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

7
ความแม่นยำ 'ลอย' เทียบกับ 'สองเท่า'
รหัส float x = 3.141592653589793238; double z = 3.141592653589793238; printf("x=%f\n", x); printf("z=%f\n", z); printf("x=%20.18f\n", x); printf("z=%20.18f\n", z); จะให้ผลลัพธ์ x=3.141593 z=3.141593 x=3.141592741012573242 z=3.141592653589793116 โดยที่บรรทัดที่สามของการส่งออก741012573242เป็นขยะและในบรรทัดที่สี่116คือขยะ คู่ผสมมีตัวเลขสำคัญ 16 ตัวเสมอหรือไม่ในขณะที่ลอยตัวมีตัวเลขสำคัญ 7 ตัวอยู่เสมอ? ทำไมคู่ไม่ได้มี 14 ตัวเลขที่สำคัญ?
155 c  floating-point 

3
ทำไมการเพิ่ม 0.1 หลาย ๆ ครั้งจึงไม่สูญเสีย
ฉันรู้ว่า0.1เลขทศนิยมไม่สามารถแสดงว่ามีจำนวนไบนารี จำกัด ( คำอธิบาย ) ดังนั้นจะสูญเสียบางอย่างแม่นยำและจะไม่ตรงdouble n = 0.1 0.1บนมืออื่น ๆสามารถแสดงว่าเพราะมันเป็น0.50.5 = 1/2 = 0.1b ต้องบอกว่ามันเป็นที่เข้าใจว่าการเพิ่ม0.1 สามครั้งจะไม่ให้0.3รหัสดังต่อไปนี้false: double sum = 0, d = 0.1; for (int i = 0; i < 3; i++) sum += d; System.out.println(sum == 0.3); // Prints false, OK แต่แล้วการเพิ่ม0.1 ห้าครั้งจะให้ได้0.5อย่างไร พิมพ์รหัสต่อไปนี้true: double sum = 0, …

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.