เอกสารใดที่บอกว่าช่วงใดของ. NET BigIntegers ที่ออกแบบมาเพื่ออะไร?

ฉันกำลังเล่นกับ. NET BigIntegerและโดยทั่วไปฉันสงสัยว่าจำนวนใด - คำตอบโดยประมาณน่าจะดี - คือจุดเบี่ยงเบนของเส้นโค้งของ (กราฟของ (เพิ่มเวลาที่จำเป็นสำหรับการปฏิบัติการ) vs (มูลค่าของ BigInteger))?

หรือพวกมันถูกออกแบบโดยไม่มีการเบี่ยงเบนเช่นนั้นถ้าเราวางแผนการเพิ่มเวลาที่จำเป็นสำหรับการดำเนินการเทียบกับมูลค่าของ BigInteger จาก 1 ถึงอินฟินิตี้เราจะมีเส้นโค้งที่ราบรื่นไปตลอดทาง?

ตัวอย่างเช่นสมมติว่าอาร์เรย์ได้รับการออกแบบที่มีความสามารถในการจัดการ 50 รายการ หมายความว่าถ้าฉันมี 1 รายการการดำเนินการจะเป็นเวลา f (1) และเมื่อฉันมี 2 รายการการดำเนินการคือ f (2) เวลา หากฉันมี 50 รายการการดำเนินการจะเป็นเวลา f (50) แต่เนื่องจากมันถูกออกแบบมาสำหรับการจัดการ 50 รายการเท่านั้นการดำเนินการเมื่อเรามี 51 รายการจะเป็น g (51) โดยที่ g (51)> f (51)

หากดำเนินการอย่างเหมาะสมความซับซ้อนของ BigInteger เลขคณิตควรเป็นเส้นโค้งที่ราบรื่น ตัวอย่างเช่นความซับซ้อนของเวลาในการคูณควรเป็น O (NM) โดยที่ N คือจำนวนหลักในการคูณแรกและ M คือจำนวนหลักในการคูณที่สอง แน่นอนว่ามีข้อ จำกัด ในทางปฏิบัติที่คุณสามารถเลือก N และ M ได้ขนาดใหญ่จนตัวเลขไม่พอดีกับเครื่องของคุณ

มีใครบ้าง / ไม่รู้ว่ามีเอกสารใดที่อ้างว่ามีการใช้งานเช่นนี้หรือไม่?

หมายเลขใด ๆ ที่อาจมีขนาดใหญ่กว่า ULong.MaxValue หรือเล็กกว่า Long.MinValue ควรแสดงโดยใช้ BigInteger

ถ้าไม่ใช่ (Long.MinValue <= X <= ULong.MaxValue) จากนั้น BigInteger

BigInteger สำหรับจำนวนที่มากเกินไปเกินกว่าที่จะสามารถจัดการได้

ตัวอย่างเช่นหากจำนวนเต็มของคุณอยู่นอกช่วง Long คุณอาจใช้ BigInteger กรณีเหล่านี้หายากมากและการใช้คลาสเหล่านี้มีค่าใช้จ่ายสูงกว่าแบบดั้งเดิมอย่างมีนัยสำคัญ

ตัวอย่างเช่นlongกว้าง 64 บิตและสามารถเก็บช่วงได้: -9,223,372,036,854,775,808 ถึง 9,223,372,036,854,775,80 ulong สามารถถือ 0 ถึง 18,446,744,073,709,551,615 หากหมายเลขของคุณใหญ่กว่าหรือเล็กกว่านั้น BigInteger เป็นตัวเลือกเดียวของคุณ

ครั้งเดียวที่ฉันเห็นพวกเขาใช้ในแอพพลิเคชั่นโลกแห่งความจริงคือแอปพลิเคชัน Starchartting

ดูเพิ่มเติมที่: ช่วงดั้งเดิมใน. NET

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

ตามที่คนอื่น ๆ ชี้ให้เห็นอูลองสามารถถือระหว่าง 0 ถึง 18,446,744,073,709,551,615 และตราบใดที่คุณยังคงอยู่ในช่วงนั้นคุณสามารถทำเลขคณิตที่แน่นอน หากคุณไปเกิน 1 ช่วงนั้นคุณจะได้รับการล้นดังนั้นคำตอบสำหรับคำถามของคุณคือใช้ BigInteger หากคุณต้องการเลขคณิตที่แน่นอนและมีความเป็นไปได้ที่ผลลัพธ์ระดับกลางใด ๆ จะเกิน 18,446,744,073,709,551,615

ปัญหาส่วนใหญ่ในวิทยาศาสตร์วิศวกรรมและการเงินสามารถอยู่กับการประมาณที่บังคับโดยตัวเลขจุดลอยตัวและไม่สามารถจ่ายค่าใช้จ่ายเวลาของการคำนวณ BigInteger ได้ การคำนวณเชิงพาณิชย์ส่วนใหญ่ไม่สามารถอยู่ได้ด้วยการประมาณเลขคณิตจุดลอยตัว แต่ทำงานในช่วง 0 ถึง 18,446,744,073,709,551,615 เพื่อให้สามารถใช้เลขคณิตทั่วไปได้ BigInteger เป็นสิ่งจำเป็นเมื่อใช้อัลกอริทึมจากทฤษฎีจำนวนซึ่งรวมถึงสิ่งต่าง ๆ เช่นการเข้ารหัส (คิดว่า 50 หลักสำคัญจำนวน) บางครั้งมันก็ถูกใช้ในแอพพลิเคชั่นเชิงพาณิชย์เมื่อต้องการการคำนวณที่แม่นยำความเร็วไม่สำคัญเกินไปและการตั้งค่าระบบจุดทศนิยมคงที่ที่เหมาะสมนั้นเป็นปัญหามากเกินไป

หากดำเนินการอย่างเหมาะสมความซับซ้อนของ BigInteger เลขคณิตควรเป็นเส้นโค้งที่ราบรื่น ตัวอย่างเช่นความซับซ้อนของเวลาในการคูณควรเป็น O (NM) โดยที่ N คือจำนวนหลักในการคูณแรกและ M คือจำนวนหลักในการคูณที่สอง แน่นอนว่ามีข้อ จำกัด ในทางปฏิบัติที่คุณสามารถเลือก N และ M ได้ขนาดใหญ่จนตัวเลขไม่พอดีกับเครื่องของคุณ

หากคุณ google "ความซับซ้อนในการคำนวณของนักสะสมภาพใหญ่" คุณจะได้รับการอ้างอิงมากกว่าที่คุณสามารถสั่นคลอนได้ หนึ่งที่พูดโดยตรงกับคำถามของคุณคือ: เปรียบเทียบสองแพคเกจความแม่นยำทางคณิตศาสตร์โดยพลการ

ขีด จำกัด หน่วยความจำ

BigInteger ขึ้นอยู่กับ int array สำหรับการจัดเก็บ สมมติว่าข้อ จำกัด ทางทฤษฎีสำหรับจำนวนสูงสุดที่ BigInteger สามารถแสดงนั้นสามารถได้มาจากขนาดอาร์เรย์สูงสุดที่มีอยู่ใน. net มีหัวข้อเกี่ยวกับอาร์เรย์อยู่ที่นี่: Finding หน่วยความจำเท่าใดฉันสามารถจัดสรรสำหรับอาร์เรย์ใน C #

สมมติว่าเรารู้ขนาดอาเรย์สูงสุดเราสามารถประมาณจำนวนสูงสุดซึ่ง BigInteger สามารถแสดง: (2 ^ 32) ^ max_array_size โดยที่:

• 2 ^ 32 - จำนวนสูงสุดในเซลล์อาร์เรย์ (int)
• max_array_size - ขนาดสูงสุดที่อนุญาตของอาร์เรย์ int ซึ่งถูก จำกัด ด้วยขนาดวัตถุ 2GB

ซึ่งจะให้ตัวเลขที่มีทศนิยม 600 ล้านหลัก

ขีด จำกัด ประสิทธิภาพ

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

เท่าที่ขนาดสูงสุดจำนวน จำกัด ไว้ที่ 2GB บนเครื่องโคตรคุณจะไม่เห็นช่องว่างประสิทธิภาพที่ไม่คาดคิด แต่การใช้งานกับตัวเลข 600 ล้านหลักจะช้าลง

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

แน่นอนว่าอัลกอริทึมมักจะช้าลงเมื่อตัวเลขมีขนาดใหญ่ขึ้น แต่ก็ไม่ช้าลงมากนัก

เมื่อคุณใช้ตัวเลขในช่วงหลักล้านคุณอาจต้องการคิดถึงวิธีแก้ปัญหาอื่น ๆ - เนื่องจากการคำนวณกับพวกมันช้าลงเช่นกัน

มีการใช้งานไม่กี่ครั้งในชุมชนวิทยาศาสตร์ (เช่นระยะห่างระหว่างกาแลกซี่จำนวนอะตอมในทุ่งหญ้าและอื่น ๆ )

ตามคำตอบของไคลน์ไคลน์ BigNumbers ถูกเพิ่มเข้าไปใน. NET primarlily เพราะพวกเขาจำเป็นต้องใช้เป็นหน่วยการสร้างสำหรับอัลกอริทึมการเข้ารหัสที่ทันสมัยจำนวนมาก (ลายเซ็นดิจิตอลการเข้ารหัสคีย์สาธารณะ / ส่วนตัว ฯลฯ ) อัลกอริทึมการเข้ารหัสลับสมัยใหม่จำนวนมากเกี่ยวข้องกับการคำนวณค่าจำนวนเต็มที่มีขนาดสูงถึงหลายพันบิต เนื่องจากคลาส BigNumber อธิบายคลาสที่กำหนดไว้อย่างดีและมีประโยชน์พวกเขาตัดสินใจที่จะทำให้เป็นสาธารณะ (แทนที่จะทำให้เป็นรายละเอียดภายในของ API การเข้ารหัสลับ)