จัดการกับตัวเลขจำนวนมากในภาษาที่ไม่สามารถ?

ฉันพยายามที่จะคิดเกี่ยวกับวิธีที่ฉันจะไปเกี่ยวกับการคำนวณในจำนวนมาก (เพื่อ infinitum - intergers ไม่ลอย) หากโครงสร้างภาษาไม่สามารถจัดการตัวเลขที่มีขนาดใหญ่กว่าค่าที่แน่นอน

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

ฉันจะร่างอัลกอริทึมแบบนี้:

1. กำหนดความยาวสูงสุดของตัวแปรจำนวนเต็มสำหรับภาษา

2. หากตัวเลขมีความยาวมากกว่าครึ่งของความยาวสูงสุดของตัวแปรที่แยกออกเป็นอาเรย์ (ให้ห้องเล่นเล็ก ๆ )

3. ลำดับ Array [0] = ตัวเลขที่อยู่ทางด้านขวา [n-max] = ตัวเลขที่อยู่ทางด้านซ้ายสุด

   อดีต Num: 29392023 Array [0]: 23, Array [1]: 20, array [2]: 39, array [3]: 29

เมื่อฉันสร้างความยาวครึ่งหนึ่งของตัวแปรเป็นจุดปิดมาร์คฉันก็สามารถคำนวณหาหนึ่งในสิบส่วนหนึ่งร้อย ฯลฯ วางผ่านเครื่องหมายครึ่งทางเพื่อที่ว่าถ้าความยาวสูงสุดของตัวแปรเท่ากับ 10 หลักจาก 0 ถึง 9999999999 ฉันรู้ว่า โดยครึ่งหนึ่งนั้นถึงห้าหลักทำให้ฉันมีห้องเล่น

ดังนั้นถ้าฉันเพิ่มหรือทวีคูณฉันสามารถมีฟังก์ชั่นตรวจสอบตัวแปรที่เห็นว่าหลักที่หก (จากด้านขวา) ของอาร์เรย์ [0] เป็นตำแหน่งเดียวกับหลักแรก (จากด้านขวา) ของอาร์เรย์ [1]

การหารและการลบมีปัญหาของตัวเองซึ่งฉันยังไม่ได้คิด

ฉันต้องการทราบเกี่ยวกับการใช้งานที่ดีที่สุดในการรองรับจำนวนที่มากขึ้นกว่าที่โปรแกรมสามารถทำได้

คุณกำลังมองหาห้องสมุดคณิตศาสตร์ที่มีความแม่นยำตามอำเภอใจ (เรียกอีกอย่างว่า "ความแม่นยำหลายอย่าง" หรือ "บิ๊กนัม") สำหรับภาษาที่คุณใช้งาน ตัวอย่างเช่นหากคุณทำงานกับ C คุณสามารถใช้ GNU Bignum Library -> http://gmplib.org/

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

มันเป็นปัญหาที่รู้จักกันดี: ความแม่นยำทางคณิตศาสตร์โดยพลการ

เมื่อภาษาที่คุณใช้ไม่สามารถแก้ไขปัญหานี้ได้อันดับแรกให้ลองหาห้องสมุดบุคคลที่สาม หากคุณไม่พบมันหรืออยากรู้อยากเห็นลองนำไปใช้ บทความวิกิพีเดียมีการอ้างอิงที่ดีเกี่ยวกับการใช้งานแบบดั้งเดิม

เมื่อต้องรับมือกับจำนวนมากอาจเป็นหนึ่งในการตัดสินใจออกแบบขั้นพื้นฐานที่สุดคือฉันจะเป็นตัวแทนของจำนวนมากได้อย่างไร

มันจะเป็นสตริงอาร์เรย์รายการหรือคลาสหน่วยเก็บข้อมูลแบบกำหนดเอง (homegrown)

หลังจากทำการตัดสินใจแล้วการดำเนินการทางคณิตศาสตร์ที่เกิดขึ้นจริงสามารถแบ่งออกเป็นส่วนย่อย ๆ แล้วดำเนินการกับชนิดภาษาท้องถิ่นเช่น int หรือจำนวนเต็ม

ฉันได้รวมตัวอย่างเพิ่มเติมพื้นฐานใน C # .Net ที่เก็บผลจำนวนมากเป็นสตริง "ตัวเลข" ที่เข้ามายังเป็นสตริงดังนั้นจึงควรส่งหมายเลข "ใหญ่" มาก โปรดจำไว้ว่าตัวอย่างเป็นเพียงตัวเลขทั้งหมดเพื่อให้ง่าย

แม้ว่าจะมีสตริง แต่ก็มีข้อ จำกัด ในจำนวนตัวอักษรหรือ "ตัวเลข" ในจำนวนดังที่ระบุไว้ที่นี่:

ความยาวสูงสุดที่เป็นไปได้ของสตริง. NET คืออะไร?

แต่คุณสามารถเพิ่มตัวเลขจำนวนมาก ๆ ได้นอกเหนือจาก int32 หรือชนิด int64 ดั้งเดิมสำหรับ. Net

อย่างไรก็ตามนี่คือการใช้งานที่เก็บสตริง

/// <summary>
/// Adds two "integers".  The integers can be of any size string.
/// </summary>
/// <param name="BigInt1">The first integer</param>
/// <param name="BigInt2">The second integer</param>
/// <returns>A string that is the addition of the two integers passed.</returns>
/// <exception cref="Exception">Can throw an exception when parsing the individual parts     of the number.  Callers should handle. </exception>
public string AddBigInts(string BigInt1, string BigInt2)
{
    string result = string.Empty;

    //Make the strings the same length, pre-pad the shorter one with zeros
    int length = (BigInt1.Length > BigInt2.Length ? BigInt1.Length : BigInt2.Length);
    BigInt1 = BigInt1.PadLeft(length, '0');
    BigInt2 = BigInt2.PadLeft(length, '0');

    int remainder = 0;

    //Now add them up going from right to left
    for (int i = (BigInt1.Length - 1); i >= 0; i--)
    {
        //If we don't encounter a number, this will throw an exception as indicated.
        int int1 = int.Parse(BigInt1[i].ToString());
        int int2 = int.Parse(BigInt2[i].ToString());

        //Add
        int add = int1 + int2 + remainder;

        //Check to see if we need a remainder;
        if (add >= 10)
        {
            remainder = 1;
            add = add % 10;
        }
        else
        {
            remainder = 0;
        }

        //Add this to our "number"
        result = add.ToString() + result;
    }

    //Handle when we have a remainder left over at the end
    if (remainder == 1)
    {
        result = remainder + result;
    }

    return result;
}

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

อันนี้ใช้ได้ผลเร็วกว่าสำหรับฉัน:

static string Add(string a, string b)
        {
            string c = null;

            if (Compare(a, b) < 0)
            {
                c = a;
                a = b;
                b = c;
            }

            StringBuilder sb = new StringBuilder();

            b = b.PadLeft(a.Length, '0');

            int r = 0;

            for (int i = a.Length - 1; i >= 0; i--)
            {
                int part = a[i] + b[i] + r - 96;

                if (part <= 9)
                {
                    sb.Insert(0, part);

                    r = 0;
                }
                else
                {
                    sb.Insert(0, part - 10);

                    r = 1;
                }
            }

            if (r == 1)
            {
                sb.Insert(0, "1");
            }

            return sb.ToString();
        }