1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:

Function BM_Add(Num1, Num2: TBigNumber): TBigNumber;
Function BM_Sub(Num1, Num2: TBigNumber): TBigNumber;
Function BM_Divide(Num1, Num2: TBigNumber): TBigNumber;
Function BM_Modulo(Num1, Num2: TBigNumber): TBigNumber;
Function BM_DivMod(Var Num1: TBigNumber; Num2: TBigNumber): TBigNumber; //Returns Int as Num1, Mod as Result
Function BM_Multiply(Num1, Num2: TBigNumber): TBigNumber;
Function BM_MultiplyMod(Num1, Num2, Module: TBigNumber): TBigNumber;
Function BM_Power(Base, Exp: TBigNumber): TBigNumber;
Function BM_PowerMod(Base, Exp, Module: TBigNumber): TBigNumber;
Function BM_Log(Power, Base: TBigNumber): TBigNumber;
Function BM_SquareRoot(Num: TBigNumber): TBigNumber;
Function BM_XRoot(Num, Exp: TBigNumber): TBigNumber;

//Compare Funktionen nach CPU-Flag-Notation
Function BM_CompareC(Num1, Num2: TBigNumber): Boolean; //Returns True if Num1<Num2
Function BM_CompareNC(Num1, Num2: TBigNumber): Boolean; //Returns True if Num1>=Num2
Function BM_CompareNZ(Num1, Num2: TBigNumber): Boolean; //Returns True if Num1<>Num2
Function BM_CompareZ(Num1, Num2: TBigNumber): Boolean; //Returns True if Num1=Num2

//Compare-Funktionen nach Arithmetischer Notation
Function BM_CompareE(Num1, Num2: TBigNumber): Boolean; //Returns True if Num1=Num2
Function BM_CompareNE(Num1, Num2: TBigNumber): Boolean; //Returns True if Num1<>Num2
Function BM_CompareL(Num1, Num2: TBigNumber): Boolean; //Returns True if Num1<Num2
Function BM_CompareLE(Num1, Num2: TBigNumber): Boolean; //Returns True if Num1<=Num2
Function BM_CompareG(Num1, Num2: TBigNumber): Boolean; //Returns True if Num1>Num2
Function BM_CompareGE(Num1, Num2: TBigNumber): Boolean; //Returns True if Num1>=Num2

//ggT und kgV
Function BM_GCD(Num1, Num2: TBigNumber): TBigNumber;
Function BM_LCM(Num1, Num2: TBigNumber): TBigNumber;

Procedure BM_Assign(Var Result: TBigNumber; Const Number: TBigNumber);
Procedure BM_Optimize(Var Result: TBigNumber);
Procedure BM_GCDOptimize(Var Num1, Num2: TBigNumber);

Function BMD_StrToBigNum(Str: String; HexInput: Boolean): TBigNumber;
Function BMD_BigNumToStr(Num: TBigNumber; HexOutput: Boolean): String;
Function BMD_FractionToStr(Num1, Num2: TBigNumber): String;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

Function BM_PowerMod(Base, Exp, Module: TBigNumber): TBigNumber;
Const
    C: Array[0..7] Of Byte = ($01, $02, $04, $08, $10, $20, $40, $80);
Var
    i, j: Integer;
Begin
    Result := BMD_StrToBigNum('1', false);
    For i := High(Exp) Downto 0 Do
    Begin
        For j := 7 Downto 0 Do
        Begin
            Result := BM_Multiply(Result, Result);
            If (Exp[i] And C[j]) > 0 Then
                Result := BM_Multiply(Result, Base);
            Result := BM_Modulo(Result, Module);
        End;
    End;
End;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:

Procedure TSJBigNumber.Power(Exp: TBigNumber);
Begin
//    Self.fNumber := BM_Multiply(Self.fNumber, Exp);
    Self.fNumber := BM_Power(Self.fNumber, Exp);
End;

Procedure TSJBigNumber.Power(Exp: TSJBigNumber);
Begin
//    Self.fNumber := BM_Multiply(Self.fNumber, Exp.Number);
    Self.fNumber := BM_Power(Self.fNumber, Exp.Number);
End;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:

{a fast multiplying algorithm for huge positive numbers by karatsuba.  }
Function BM_MultiplyKaratsuba(Num1, Num2: TBigNumber): TBigNumber;
Var i, n2, n:Integer;
    Num1_high, Num1_low, Num2_high, Num2_low:TBigNumber;
    P1, P2, P3:TBigNumber;
Begin
   if Length(Num1) > Length(Num2) then
      n2 := Length(Num1)
   else
      n2 := Length(Num2);
   if odd(n2) then inc(n2);
   if n2 < 9 then  //short numbers by simple multiplication
      begin
      Result := BM_Multiply(Num1, Num2);
      exit;
      end;
   n := n2 div 2;

   SetLength(Num1_low,n); SetLength(Num2_low,n);
   for i:=0 to n -1 do
     begin
     if i < Length(Num1) then Num1_low[i]:=Num1[i] else Num1_low[i] := 0;
     if i < Length(Num2) then Num2_low[i]:=Num2[i] else Num2_low[i] := 0;
     end;
   SetLength(Num1_high,n); SetLength(Num2_high,n);
   for i:=n to n2 - 1 do
     begin
     if i < Length(Num1) then Num1_high[i - n]:=Num1[i] else Num1_high[i - n] := 0;
     if i < Length(Num2) then Num2_high[i - n]:=Num2[i] else Num2_high[i - n] := 0;
     end;
   P1 := BM_MultiplyKaratsuba(Num1_high, Num2_high); 
   P2 := BM_MultiplyKaratsuba(Num1_low, Num2_low);
   P3 := BM_MultiplyKaratsuba(BM_Add(Num1_high,Num1_low), BM_Add(Num2_high,Num2_low));
   SetLength(Result, n2 * 2); FillChar(Result[0],n2 * 2,0);
   for i:=0 to Length(P1)-1 do Result[i+n2] := P1[i];      // Result == P1 * base^2n
   Result := BM_Add(Result, P2);                           // Result == P1 * base^2n + P2
   P3 := BM_Sub(P3,P1);
   P3 := BM_Sub(P3,P2);                                    // P3 - P1 - P2
   Setlength(P1, n2 * 2); FillChar(P1[0],n2 * 2,0);        // reusing P1 as tmp variable
   for i:=0 to Length(P3)-1 do P1[i + n] := P3[i];         // (P3 -P1 -P2) * base^n
   Result := BM_Add(Result, P1);                           // Result == P1 * base^2n + P2 + (P3 -P1 -P2) * base^n
   BM_Optimize(Result);
End;                    

1:
2:
3:
4:

function IntToBigNum(Int: Integer):TBigNumber;
begin
 result := BMD_StrToBigNum(inttostr(Int), false);
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:

Function  BM_Add(Num1, Num2: TSignedBigNumber): TSignedBigNumber;
Function  BM_Sub(Num1, Num2: TSignedBigNumber): TSignedBigNumber;
Function  BM_Divide(Num1, Num2: TSignedBigNumber): TSignedBigNumber;
Function  BM_Multiply(Num1, Num2: TSignedBigNumber): TSignedBigNumber;
Function  BM_Power(Base, Exp: TSignedBigNumber): TSignedBigNumber;

Function  BM_Abs(Num: TSignedBigNumber): TSignedBigNumber;
Function  BM_Div(Num1, Num2: TSignedBigNumber): TSignedBigNumber;
Function  BM_Mod(Num1, Num2: TSignedBigNumber): TSignedBigNumber;
Function  BM_Even(Num: TSignedBigNumber):boolean;
Function  BM_Odd(Num: TSignedBigNumber):boolean;

Function  BM_CompareC(Num1, Num2: TSignedBigNumber): Boolean;  //Returns True if Num1<Num2
Function  BM_CompareNC(Num1, Num2: TSignedBigNumber): Boolean; //Returns True if Num1>=Num2
Function  BM_CompareNZ(Num1, Num2: TSignedBigNumber): Boolean; //Returns True if Num1<>Num2
Function  BM_CompareZ(Num1, Num2: TSignedBigNumber): Boolean;  //Returns True if Num1=Num2
Function  BM_CompareE(Num1, Num2: TSignedBigNumber): Boolean;  //Returns True if Num1=Num2
Function  BM_CompareNE(Num1, Num2: TSignedBigNumber): Boolean; //Returns True if Num1<>Num2
Function  BM_CompareL(Num1, Num2: TSignedBigNumber): Boolean;  //Returns True if Num1<Num2
Function  BM_CompareLE(Num1, Num2: TSignedBigNumber): Boolean; //Returns True if Num1<=Num2
Function  BM_CompareG(Num1, Num2: TSignedBigNumber): Boolean;  //Returns True if Num1>Num2
Function  BM_CompareGE(Num1, Num2: TSignedBigNumber): Boolean; //Returns True if Num1>=Num2

Procedure BM_Assign(Var Result: TSignedBigNumber; Const Number: int64);            Overload; //careful, only –2^63..2^63–1
Procedure BM_Assign(Var Result: TSignedBigNumber; Const Number: TBigNumber);       Overload;
Procedure BM_Assign(Var Result: TSignedBigNumber; Const Number: TSignedBigNumber); Overload;

Function  BMD_StrToSignedBigNum(Str: String; HexInput: Boolean): TSignedBigNumber;
Function  BMD_SignedBigNumToStr(Num: TSignedBigNumber; HexOutput: Boolean): String;

{ implementation of extended euclidian algorithm: GCD_ext }
Function  GCD_ext(a, b: TSignedBigNumber; var u,v: TSignedBigNumber): TSignedBigNumber;  { Result = GCD(a,b) and also GCD(a,b) = u*a + v*b }
Function  phi(p,q:TBigNumber):TBigNumber;                                                { Result = (p-1)*(q-1) }
Function  NextPrime(Num, Samples:TSignedBigNumber):TSignedBigNumber;                     { Samples determines how securly a prime is returned. Result => Num if Num is prime ; next prime otherwise }
Function  MillerRabin(Num, NumSamples: TSignedBigNumber):boolean;                        { checks Num to be prime; see comment at implementation }
Function  BM_Random(minimum, maximum:TBigNumber):TBigNumber;                             { generate random number }                    

1:
2:
3:
4:
5:
6:
7:
8:
9:

procedure TForm1.Button1Click(Sender: TObject);
var
  B1, B2, BR: TBigNumber;
begin
  B1 := BMD_StrToBigNum('12345', false);
  B2 := BMD_StrToBigNum('5', false);
  BR := BM_Modulo(B1, B2);
  Caption := BMD_BigNumToStr(BR, false);
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

procedure TSJBigNumber.GCD(Num2: TSJBigNumber);
begin
  if(self.fSign=0) and (Num2.Sign=0) then begin
    //raise EMathError.Create('GCD of (0,0) is not defined');
    exit;//gcd(0,0):=0 (per algebraischer Definition)
  end;
  if(Num2.fSign<>0) then begin
    if(self.fSign=0) then self.Assign(Num2) //gcd(0,a)=|a|
    else self.fNumber:=BM_GCD(self.fNumber,Num2.Number);
  end;
  //else ggt(a,0)=|a|
  self.fSign:=1;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:

Function BM_Add(Num1, Num2: TBigNumber): TBigNumber;
Var
    X: Integer;
    O: Integer;
Begin
    SetLength(Result, Max(Length(Num1), Length(Num2)) + 1);
    FillChar(Result[0], Length(Result), 0);

    O := 0;
    For X := 0 To High(Result) Do
    Begin
        If X < Length(Num1) Then
            O := O + Num1[X];
        If X < Length(Num2) Then
            O := O + Num2[X];

        Result[X] := O And $FF;
        O := O And $FF00 Shr 8;
    End;
    BM_Optimize(Result);
End;                    

1:

Function BMD_StrToBigNum(Str: String; HexInput: Boolean): TBigNumber;                    

1:
2:
3:
4:
5:
6:
7:
8:

var
  A, B: TBigInt;
begin
  A := '4000000000000000000001'; // Implicit string conversion
  B := 5; // Implicit integer conversion

  // Arbitrary math expression
  ShowMessage(IntToStr(A mod B + 2)); // 3                    

1:
2:
3:
4:
5:
6:

var a: Int64;
    x: Array of TBigNumber;
begin
  a := 4294967290;
  setLength(x, a);
end;                    

1:
2:
3:
4:
5:
6:
7:
8:

procedure TForm1.Button1Click(Sender: TObject);
VAR Zahl1,Zahl2: TBigNumber;
begin
  Zahl1:=-2;
  Zahl2:=0.05;
  Zahl1:=Multiply(Zahl1); //Zahl1 quadrieren
  Zah2:=Add(Zahl1);       //Zahl1+Zahl2
end;                    

1:

Zahl1 := BMD_StrToBigNum('123');                    

1:

If Result = '' Then Result := '0';