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;