คณิตศาสตร์เลขทศนิยมนั้นสอดคล้องกันใน C # หรือไม่ เป็นไปได้ไหม

ไม่นี่ไม่ใช่คำถาม"ทำไมจึงเป็น (1 / 3.0) * 3! = 1"

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

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

นี้เกิดขึ้นแม้กระทั่งในหมู่ประมวลผลว่า "ตาม" มาตรฐาน IEEE-754หลักเพราะบางหน่วยประมวลผล (คือ x86) ใช้ความแม่นยำขยายคู่ นั่นคือพวกเขาใช้การลงทะเบียน 80 บิตเพื่อทำการคำนวณทั้งหมดจากนั้นตัดเป็น 64- บิตหรือ 32 บิตซึ่งนำไปสู่ผลลัพธ์การปัดเศษที่แตกต่างกันกว่าเครื่องที่ใช้ 64- บิตหรือ 32- บิตสำหรับการคำนวณ

ฉันเห็นวิธีแก้ไขปัญหาออนไลน์หลายวิธี แต่ทั้งหมดสำหรับ C ++ ไม่ใช่ C #:

• ปิดใช้งานโหมดขยายความแม่นยำสองเท่า (เพื่อให้การdoubleคำนวณทั้งหมดใช้ IEEE-754 64- บิต) โดยใช้_controlfp_s(Windows), _FPU_SETCW(Linux?) หรือfpsetprec(BSD)
• เรียกใช้คอมไพเลอร์เดียวกันด้วยการตั้งค่าการปรับให้เหมาะสมที่สุดเสมอและกำหนดให้ผู้ใช้ทุกคนมีสถาปัตยกรรม CPU เดียวกัน (ไม่มีการเล่นข้ามแพลตฟอร์ม) เนื่องจาก "คอมไพเลอร์" ของฉันเป็นจริง JIT ซึ่งอาจปรับให้เหมาะสมแตกต่างกันทุกครั้งที่รันโปรแกรมฉันไม่คิดว่ามันเป็นไปได้
• ใช้เลขคณิตจุดคงที่และหลีกเลี่ยงfloatและdoubleทั้งหมด decimalจะทำงานเพื่อจุดประสงค์นี้ แต่จะช้ากว่านี้มากและไม่มีSystem.Mathฟังก์ชันไลบรารีใดสนับสนุน

ดังนั้นนี่เป็นปัญหาใน C # หรือไม่ ถ้าฉันตั้งใจจะสนับสนุน Windows เท่านั้น (ไม่ใช่ Mono)

ถ้าเป็นเช่นนั้นมีวิธีใดที่จะบังคับให้โปรแกรมของฉันทำงานที่ความแม่นยำสองเท่าปกติหรือไม่?

ถ้าไม่มีมีห้องสมุดใดบ้างที่จะช่วยให้การคำนวณจุดลอยตัวสอดคล้องกันหรือไม่

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

วิธีแก้ปัญหาที่ฉันพิจารณา:

1. ใช้ FixedPoint32 ใน C # แม้ว่านี่จะไม่ยากเกินไป (ฉันมีการนำไปใช้งานแล้วเสร็จครึ่งหนึ่ง) ช่วงของค่าที่น้อยมากทำให้มันน่ารำคาญที่จะใช้ คุณต้องระวังตลอดเวลาดังนั้นคุณจึงไม่ล้นและไม่แม่นยำจนเกินไป ในที่สุดฉันพบว่ามันไม่ง่ายกว่าการใช้จำนวนเต็มโดยตรง
2. ใช้ FixedPoint64 ใน C # ฉันพบว่ามันค่อนข้างยากที่จะทำ สำหรับการดำเนินการบางอย่างจำนวนเต็มระดับกลางของ 128 บิตจะเป็นประโยชน์ แต่. net ไม่ได้เสนอประเภทดังกล่าว
3. ใช้ floatingpoint 32 บิตแบบกำหนดเอง การไม่มี BitScanReverse ภายในทำให้เกิดความรำคาญเล็กน้อยเมื่อใช้งานสิ่งนี้ แต่ปัจจุบันฉันคิดว่านี่เป็นเส้นทางที่มีแนวโน้มมากที่สุด
4. ใช้รหัสเนทีฟสำหรับการดำเนินการทางคณิตศาสตร์ เกิดค่าใช้จ่ายในการโทรของผู้รับมอบสิทธิ์ในการดำเนินการทางคณิตศาสตร์ทุกครั้ง

ฉันเพิ่งเริ่มต้นใช้งานซอฟต์แวร์ของเลขทศนิยม 32 บิต สามารถเพิ่ม / การคูณได้ 70million ต่อวินาทีใน 2.66GHz i3 ของฉัน https://github.com/CodesInChaos/SoftFloat เห็นได้ชัดว่ามันยังไม่สมบูรณ์และมีบักกี้

ข้อมูลจำเพาะ C # (§4.1.6ชนิดจุดลอยตัว) ช่วยให้การคำนวณจุดลอยตัวทำได้โดยใช้ความแม่นยำสูงกว่าผลลัพธ์ ดังนั้นไม่ฉันไม่คิดว่าคุณสามารถคำนวณได้โดยตรงใน. Net คนอื่นแนะนำวิธีแก้ปัญหาต่าง ๆ ดังนั้นคุณสามารถลองได้

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

http://www.math.utah.edu/~beebe/software/ieee/

หมายเหตุเกี่ยวกับจุดคงที่

หมายเลขจุดคงที่ไบนารียังสามารถทำงานได้ดีแทนจุดลอยตามที่เห็นได้จากการดำเนินการทางคณิตศาสตร์สี่ขั้นพื้นฐาน:

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

เลขฐานคงที่แบบไบนารีสามารถนำไปใช้กับชนิดข้อมูลจำนวนเต็มใด ๆ เช่น int, long และ BigInteger และประเภทที่ไม่สอดคล้องกับ CLS uint และ ulong

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

// Assume each number has a 12 bit fractional part. (1/4096)
// Each entry in the lookup table corresponds to a fixed point number
//  with an 8-bit fractional part (1/256)
input+=(1<<3); // Add 2^3 for rounding purposes
input>>=4; // Shift right by 4 (to get 8-bit fractional part)
// --- clamp or restrict input here --
// Look up value.
return lookupTable[input];

นี่เป็นปัญหาสำหรับ C # หรือไม่

ใช่. สถาปัตยกรรมที่แตกต่างกันคือความกังวลของคุณน้อยที่สุด framerates ที่แตกต่างกัน ฯลฯ สามารถนำไปสู่การเบี่ยงเบนเนื่องจากความไม่ถูกต้องในการเป็นตัวแทนลอย - แม้ว่าพวกเขาจะไม่ถูกต้องเหมือนกัน (เช่นสถาปัตยกรรมเดียวกันยกเว้น GPU ช้าลงในเครื่องเดียว)

ฉันสามารถใช้ System.Decimal ได้หรือไม่

ไม่มีเหตุผลที่คุณทำไม่ได้ แต่มันเป็นสุนัขที่ช้า

มีวิธีบังคับให้โปรแกรมของฉันทำงานด้วยความแม่นยำสองเท่าหรือไม่?

ใช่. เป็นเจ้าภาพรันไทม์ CLR ตัวเอง ; และคอมไพล์ในการเรียก / แฟล็ก nessecary ทั้งหมด (ซึ่งเปลี่ยนพฤติกรรมของเลขทศนิยม) ในแอพพลิเคชั่น C ++ ก่อนเรียก CorBindToRuntimeEx

มีห้องสมุดใดบ้างที่จะช่วยให้การคำนวณจุดลอยตัวสอดคล้องกันหรือไม่

ไม่ใช่ที่ฉันรู้

มีวิธีอื่นในการแก้ปัญหานี้หรือไม่?

ฉันได้จัดการปัญหานี้มาก่อนความคิดที่จะใช้QNumbers พวกเขาเป็นรูปแบบของ reals ที่เป็นจุดคงที่; แต่ไม่ใช่จุดคงที่ในฐาน -10 (ฐานสิบ) - ค่อนข้างฐาน -2 (ไบนารี); ด้วยเหตุนี้พื้นฐานทางคณิตศาสตร์กับพวกเขา (เพิ่ม, ย่อย, มัล, div) จะเร็วกว่าจุดคงที่ฐานไร้เดียงสา -10; โดยเฉพาะอย่างยิ่งถ้าnเหมือนกันสำหรับทั้งสองค่า (ซึ่งในกรณีของคุณมันจะเป็น) นอกจากนี้เนื่องจากเป็นส่วนสำคัญจึงมีผลลัพธ์ที่ชัดเจนในทุกแพลตฟอร์ม

โปรดจำไว้ว่า framerate ยังสามารถส่งผลกระทบต่อสิ่งเหล่านี้ได้ แต่มันก็ไม่ได้แย่และแก้ไขได้อย่างง่ายดายโดยใช้จุดประสาน

ฉันสามารถใช้ฟังก์ชันทางคณิตศาสตร์เพิ่มเติมกับ QNumbers ได้หรือไม่

ใช่ปัดเศษทศนิยมเพื่อทำสิ่งนี้ นอกจากนี้คุณควรใช้ตารางการค้นหาสำหรับฟังก์ชัน trig (sin, cos); เนื่องจากสิ่งเหล่านี้สามารถให้ผลลัพธ์ที่แตกต่างกันอย่างแท้จริงบนแพลตฟอร์มที่แตกต่างกัน - และหากคุณเขียนโค้ดให้ถูกต้อง

ตามรายการบล็อก MSDNเก่านี้เล็กน้อยJIT จะไม่ใช้ SSE / SSE2 สำหรับจุดลอยตัวมันคือ x87 ทั้งหมด ด้วยเหตุนี้ดังที่คุณกล่าวถึงคุณต้องกังวลเกี่ยวกับโหมดและแฟล็กและใน C # ที่ไม่สามารถควบคุมได้ ดังนั้นการใช้การดำเนินการจุดลอยตัวปกติจะไม่รับประกันผลลัพธ์ที่เหมือนกันทุกเครื่องสำหรับโปรแกรมของคุณ

เพื่อให้ได้ความแม่นยำซ้ำของความแม่นยำสองเท่าคุณจะต้องทำการจำลองจุดลอยตัว (หรือจุดตรึง) ฉันไม่รู้ห้องสมุด C # ที่จะทำสิ่งนี้

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

• เก็บค่าทั้งหมดที่คุณใส่ใจด้วยความแม่นยำเดียว
• เพื่อดำเนินการ:
  • ขยายอินพุตเพื่อความแม่นยำสองเท่า
  • ดำเนินการด้วยความแม่นยำสองเท่า
  • แปลงผลลัพธ์กลับเป็นความแม่นยำเดียว

ปัญหาใหญ่ของ x87 คือการคำนวณอาจทำได้ในความแม่นยำ 53 บิตหรือ 64 บิตขึ้นอยู่กับการตั้งค่าความแม่นยำและการลงทะเบียนที่หกไปยังหน่วยความจำ แต่สำหรับการดำเนินการหลาย ๆ การการดำเนินการด้วยความแม่นยำสูงและการปัดเศษกลับไปสู่ความแม่นยำที่ต่ำกว่าจะรับประกันคำตอบที่ถูกต้องซึ่งหมายความว่าคำตอบนั้นจะรับประกันว่าจะเหมือนกันในทุกระบบ ไม่ว่าคุณจะได้รับความแม่นยำที่เพิ่มขึ้นจะไม่สำคัญเพราะคุณมีความแม่นยำเพียงพอที่จะรับประกันคำตอบที่ถูกต้องในทั้งสองกรณี

การดำเนินการที่ควรทำงานในรูปแบบนี้: การบวกการลบการคูณการหาร sqrt สิ่งต่าง ๆ เช่นบาปประสบการณ์ ฯลฯ จะไม่ทำงาน (ผลลัพธ์มักจะตรงกัน แต่ไม่มีการรับประกัน) "การปัดเศษสองครั้งไม่มีอันตรายเมื่อใด?" การอ้างอิง ACM (การชำระเงินต้องใหม่)

หวังว่านี่จะช่วยได้!

ตามที่ระบุไว้แล้วโดยคำตอบอื่น ๆ : ใช่นี่เป็นปัญหาใน C # - แม้ในขณะที่อยู่ใน Windows ที่บริสุทธิ์

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

ตามที่ร้องขอโดย OP - เกี่ยวกับประสิทธิภาพ:

System.Decimalแทนตัวเลขด้วย 1 บิตสำหรับเครื่องหมายและจำนวนเต็ม 96 บิตและ "สเกล" (แสดงถึงตำแหน่งทศนิยม) สำหรับการคำนวณทั้งหมดคุณต้องดำเนินการกับโครงสร้างข้อมูลนี้และไม่สามารถใช้คำสั่ง floating point ใด ๆ ที่อยู่ภายใน CPU

BigInteger"การแก้ปัญหา" ทำอะไรบางอย่างที่คล้ายกัน - เดียวที่คุณสามารถกำหนดวิธีการที่ตัวเลขที่คุณต้องการ / ต้องการ ... บางทีคุณอาจต้องการเพียง 80 บิตหรือ 240 บิตของความแม่นยำ

ความเชื่องช้ามาจากการจำลองการทำงานทั้งหมดในหมายเลขเหล่านี้ผ่านคำแนะนำเฉพาะจำนวนเต็มเท่านั้นโดยไม่ต้องใช้คำสั่ง CPU / FPU ในตัวซึ่งจะนำไปสู่คำแนะนำเพิ่มเติมต่อการดำเนินการทางคณิตศาสตร์

เพื่อลดประสิทธิภาพการเข้าชมมีกลยุทธ์หลายอย่าง - เช่น QNumbers (ดูคำตอบจาก Jonathan Dickinson - คณิตศาสตร์เลขลอยตัวสอดคล้องกันใน C # หรือไม่? ) และ / หรือแคช (เช่นการคำนวณตรีโกณฯ ... ) เป็นต้น

ต่อไปนี้เป็นความพยายามครั้งแรกของฉันในการทำสิ่งนี้ :

1. สร้างโครงการ ATL.dll ที่มีวัตถุง่าย ๆ ในนั้นเพื่อใช้สำหรับการดำเนินการจุดลอยตัวที่สำคัญของคุณ ตรวจสอบให้แน่ใจว่าได้รวบรวมด้วยค่าสถานะที่ปิดใช้งานโดยใช้ฮาร์ดแวร์ที่ไม่ใช่ xx87 เพื่อทำทศนิยม
2. สร้างฟังก์ชั่นที่เรียกใช้การดำเนินการจุดลอยตัวและส่งคืนผลลัพธ์ เริ่มต้นง่ายๆแล้วถ้ามันใช้งานได้สำหรับคุณคุณสามารถเพิ่มความซับซ้อนเพื่อตอบสนองความต้องการด้านประสิทธิภาพในภายหลังได้หากจำเป็น
3. วางการเรียก control_fp รอบ ๆ คณิตศาสตร์ที่แท้จริงเพื่อให้แน่ใจว่ามันจะทำแบบเดียวกันกับทุกเครื่อง
4. อ้างอิงไลบรารีใหม่ของคุณและทดสอบเพื่อให้แน่ใจว่าทำงานได้ตามที่คาดไว้

(ฉันเชื่อว่าคุณสามารถรวบรวมเป็น 32- บิต .dll จากนั้นใช้กับ x86 หรือ AnyCpu [หรือมีแนวโน้มเพียงกำหนดเป้าหมาย x86 บนระบบ 64 บิตดูความคิดเห็นด้านล่าง])

ถ้าสมมุติว่ามันใช้งานได้คุณควรใช้ Mono ฉันคิดว่าคุณน่าจะสามารถทำซ้ำไลบรารี่บนแพลตฟอร์ม x86 อื่น ๆ ในลักษณะที่คล้ายกัน (ไม่ใช่ COM แน่นอนแม้ว่าอาจจะมีไวน์หรือไม่ออกจากพื้นที่ของฉันเพียงครั้งเดียว เราไปที่นั่น ... )

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

ฉันไม่ใช่นักพัฒนาเกมถึงแม้ว่าฉันจะมีประสบการณ์มากมายกับปัญหาที่ยากในการคำนวณ ... ดังนั้นฉันจะทำให้ดีที่สุด

กลยุทธ์ที่ฉันจะนำมาใช้เป็นหลักนี้:

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

ความยาวย่อของสิ่งนี้คือคุณต้องหายอดเงินคงเหลือ หากคุณใช้การเรนเดอร์ 30ms (~ 33fps) และเพียง 1ms ทำการตรวจจับการชน (หรือแทรกการดำเนินการที่มีความไวสูงอื่น ๆ ) - แม้ว่าคุณจะใช้เวลาสามเท่าในการคำนวณทางคณิตศาสตร์ที่สำคัญ คุณลดลงจาก 33.3fps เป็น 30.3fps

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

การตรวจสอบลิงก์ในคำตอบอื่น ๆ ทำให้ชัดเจนว่าคุณจะไม่รับประกันว่าจะมีการใช้ "ถูกต้อง" หรือไม่หรือคุณจะได้รับความแม่นยำแน่นอนสำหรับการคำนวณที่กำหนด แต่บางทีคุณอาจพยายามอย่างดีที่สุดด้วย (1) การตัดการคำนวณทั้งหมดให้น้อยที่สุด (เช่นหากการใช้งานที่แตกต่างกันจะให้ความแม่นยำ 32 ถึง 80 บิตให้ตัดการทำงานทุกครั้งเป็น 30 หรือ 31 บิต) (2) มีตารางกรณีทดสอบสองสามรายการเมื่อเริ่มต้น (กรณีเส้นขอบของการเพิ่ม, ลบ, คูณ, หาร, sqrt, cosine, ฯลฯ ) และหากการใช้งานคำนวณค่าที่ตรงกับตารางแล้วไม่รบกวนการปรับเปลี่ยนใด ๆ

คำถามของคุณในสิ่งที่ค่อนข้างยากและทางเทคนิค O_o อย่างไรก็ตามฉันอาจมีความคิด

คุณแน่ใจหรือไม่ว่า CPU ทำการปรับบางอย่างหลังจากการดำเนินการลอยตัว และ CPU มีคำแนะนำที่แตกต่างกันซึ่งทำให้การปัดเศษแตกต่างกัน

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

'ความผิดพลาด' ที่เกิดจากการปรับการปัดเศษจะเพิ่มขึ้นในแต่ละคำแนะนำเพิ่มเติม

ในฐานะที่เป็นตัวอย่างเราสามารถพูดได้ว่าในระดับการประกอบ: a * b * c ไม่เทียบเท่ากับ * c * b

ฉันไม่แน่ใจทั้งหมดคุณจะต้องถามคนที่รู้จักสถาปัตยกรรม CPU มากกว่าฉัน: p

อย่างไรก็ตามในการตอบคำถามของคุณ: ใน C หรือ C ++ คุณสามารถแก้ปัญหาของคุณได้เนื่องจากคุณสามารถควบคุมรหัสเครื่องที่คอมไพเลอร์ของคุณสร้างขึ้นได้อย่างไรก็ตามใน. NET คุณไม่มีอะไรเลย ดังนั้นตราบใดที่รหัสเครื่องของคุณอาจแตกต่างกันคุณจะไม่แน่ใจเกี่ยวกับผลลัพธ์ที่แน่นอน

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

ฉันหวังว่าฉันชัดเจนเพียงพอฉันไม่เก่งภาษาอังกฤษ (... เลย: s)