Arbejde med kæmpe tal i programmering!

jeg har fundet et kodeeksempel, hvor en gut udregner 2k decimaler på pi... det kan være der er noget du kan bruge :-)
http://www.personalmicrocosms.com/html/cspc_samples_pi.html

Måske er det dette du leder efter?

http://www.codeproject.com/csharp/BigInteger.asp

Herunder er noget jeg lige har hakket sammen. Det er en god øvelse i operator-overload. Pt. understøtter klassen kun addition og multiplikation.

// (c) 2005 Copyright, Niels K. Handest
using System;
using System.Collections;

namespace HugeInt
{
    public struct HugeInt
    {
        // Each "digit" is porebtioly in range 0-18.446.744.073.709.551.615 = 0 - 2^64-1.
        private ulong[] Digit;

        // However, I'm restricting to the subrabge 0-999.999.999 since this ensures that
        // Digit*Digit is also within ulong-range.
        private const byte CiffersPerDigit = 9;
        private static readonly ulong Radix = (ulong) Math.Pow(10, CiffersPerDigit);

        public HugeInt(string AsString)
        {
            ArrayList ProtoDigit = new ArrayList();

            while (AsString != "")
            {
                int Pos = AsString.Length - CiffersPerDigit;
                if (Pos < 0) Pos = 0;

                int Len = CiffersPerDigit;
                if (AsString.Length < Len) Len = AsString.Length;

                string ProtoDigitStr = AsString.Substring(Pos, Len);
                ProtoDigit.Add(ulong.Parse(ProtoDigitStr));

                AsString = AsString.Substring(0, Pos);               
            }

            int NoOfDigits = ProtoDigit.Count;
            Digit = new ulong[NoOfDigits];
            ProtoDigit.CopyTo(Digit);
        }

        public override string ToString()
        {
            int Len = Digit.Length;

            string Result = Digit[Len-1].ToString();

            for (int i=Len-2; i>=0; i--)
                Result += Digit[i].ToString().PadLeft(CiffersPerDigit, '0');

            return Result;
        }

        public static HugeInt operator +(HugeInt A, HugeInt B)
        {
            ArrayList TempDigit = new ArrayList();

            int Len = Math.Max(A.Digit.Length, B.Digit.Length);

            ulong Carry = 0;
            for (int Idx=0; Idx<Len; Idx++)
            {
                ulong ADigit = (Idx<A.Digit.Length) ? A.Digit[Idx] : 0;
                ulong BDigit = (Idx<B.Digit.Length) ? B.Digit[Idx] : 0;

                ulong CDigit = checked(Carry + ADigit + BDigit);
                Carry = CDigit / Radix;
                CDigit = CDigit % Radix;

                TempDigit.Add(CDigit);
            }
            if (Carry > 0) TempDigit.Add(Carry);

            HugeInt Result = new HugeInt();
            Result.Digit = new ulong[TempDigit.Count];
            TempDigit.CopyTo(Result.Digit);

            return Result;
        }

        public static HugeInt operator <<(HugeInt A, int B)
        {
            ArrayList TempDigit = new ArrayList();

            for (int Idx=1; Idx<=B; Idx++)
                TempDigit.Add((ulong)0);

            for (int AIdx=0; AIdx<A.Digit.Length; AIdx++)
                TempDigit.Add(A.Digit[AIdx]);

            HugeInt Result = new HugeInt();
            Result.Digit = new ulong[TempDigit.Count];
            TempDigit.CopyTo(Result.Digit);

            return Result;
        }

        public static HugeInt operator *(HugeInt A, ulong B)
        {
            if (B >= Radix)
                throw new System.ArgumentOutOfRangeException("Faxtor should be less than " + Radix);

            ArrayList TempDigit = new ArrayList();

            ulong Carry = 0;
            for (int AIdx=0; AIdx<A.Digit.Length; AIdx++)
            {
                ulong ADigit = A.Digit[AIdx];

                ulong CDigit = checked(Carry + ADigit*B);
                Carry = CDigit / Radix;
                CDigit = CDigit % Radix;

                TempDigit.Add(CDigit);
            }
            if (Carry > 0) TempDigit.Add(Carry);

            HugeInt Result = new HugeInt();
            Result.Digit = new ulong[TempDigit.Count];
            TempDigit.CopyTo(Result.Digit);

            return Result;
        }

        public static HugeInt operator *(HugeInt A, HugeInt B)
        {
            HugeInt Result = new HugeInt("");

            for (int AIdx=0; AIdx<A.Digit.Length; AIdx++)
            {
                ulong ADigit = A.Digit[AIdx];

                Result += (B<<AIdx) * ADigit;
            }

            return Result;
        }
    }
}

Udregning af 1000!

            HugeInt Frak = new HugeInt("1");  // 0! = 1

            for (int i=1; i<=1000; i++)
            {
                Frak *= (ulong)i;
                Console.WriteLine("{0}: {1}", i, Frak);
            }

Udregning af 2^1000

            HugeInt Pow = new HugeInt("1");

            for (int i=1; i<=30; i++)
            {
                Pow *= 2;
                Console.WriteLine("{0}: {1}", i, Pow);
            }

fanatic> Var det det du skulle bruge, eller hvad?

Eftersom at vi har brugt tid på dit spørgsmål kunne du i det mindste reagere.

niele>> JA!! Jeg takker mange gange for hjælpen. Send et svar ellers kan jeg jo ikke give dig point ;-)

Svar :^)

Du har ikke brug for at kunne dividere og subtrahere?

?

Nej....problemet er løst. Mange tak for hjælpen ;-)

Selv tak. :^)