Changeset 55 for branches/ByteArray/BigInt.pas

Timestamp:

Nov 22, 2023, 10:09:35 PM (20 months ago)

Author:

chronos

Message:

• Modified: Extended BigInt type implementation.

File:

• branches/ByteArray/BigInt.pas (modified) (12 diffs)

branches/ByteArray/BigInt.pas

@@ -36 +36 @@
     class operator Implicit(A: TBigInt): Int64;
     class operator Implicit(A: TBigInt): PByte;
+    class operator Negative(A: TBigInt): TBigInt;
     class operator Inc(A: TBigInt) : TBigInt;
     class operator Dec(A: TBigInt) : TBigInt;
@@ -46 +47 @@
     class operator GreaterThan(A, B: TBigInt): Boolean;
     class operator GreaterThanOrEqual(A, B: TBigInt): Boolean;
+    class operator BitwiseXor(A, B: TBigInt): TBigInt;
+    class operator BitwiseAnd(A, B: TBigInt): TBigInt;
+    class operator BitwiseOr(A, B: TBigInt): TBigInt;
+    class operator LeftShift(A: TBigInt; B: Integer): TBigInt;
+    class operator RightShift(A: TBigInt; B: Integer): TBigInt;
+    class operator Modulus(A, B: TBigInt): TBigInt;
+    class operator IntDivide(A, B: TBigInt): TBigInt;
     procedure Shrink;
     function IsNegative: Boolean;
     function IsZero: Boolean;
     function IsPositive: Boolean;
+    procedure Invert;
     procedure SetByteArray(AData: TArrayOfByte; ASize: TBigIntSize);
     procedure GetByteArray(var AData: TArrayOfByte; ASize: TBigIntSize);
-    function Copy(Size: TBigIntSize): TBigInt;
+    function Copy(Size: TBigIntSize): TBigInt; overload;
+    function Copy: TBigInt; overload;
     property Size: TBigIntSize read GetSize write SetSize;
     property Data[Index: TBigIntSize]: Byte read GetData write SetData;
@@ -58 +68 @@
 
 function TryStrToBigInt(const S: string; out I: TBigInt): Boolean;
+function IntToStr(Value: TBigInt): string; overload;
+function IntToHex(Value: TBigInt): string; overload;
+function IntToHex(Value: TBigInt; Digits: Integer): string; overload;
 
 
@@ -64 +77 @@
 resourcestring
   SUnsupportedByteSize = 'Unsupported byte size';
+  SOutOfRange = 'Out of range';
+
+const
+   HexDigits: array[0..15] of Char = '0123456789ABCDEF';
 
 function TryStrToBigInt(const S: string; out I: TBigInt): Boolean;
@@ -73 +90 @@
 end;
 
+function IntToHex(Value: TBigInt): string;
+begin
+  Result := '';
+  while Value <> 0 do begin
+    Result := HexDigits[Value and 15] + Result;
+    Value := Value shr 4;
+  end;
+  if Result = '' then Result := '0';
+end;
+
+function IntToHex(Value: TBigInt; Digits: Integer): string;
+var
+  I: Integer;
+begin
+  if Digits = 0 then
+    Digits := 1;
+  Result := '';
+  SetLength(Result, Digits);
+  for I := 0 to Digits - 1 do
+  begin
+    Result[Digits - I] := HexDigits[Value and 15];
+    Value := Value shr 4;
+  end ;
+  while Value <> 0 do begin
+    Result := HexDigits[Value and 15] + Result;
+    Value := Value shr 4;
+  end;
+end;
+
+function IntToStr(Value: TBigInt): string;
+begin
+  Result := '';
+  if Value < 0 then begin
+    Value := -Value;
+    while Value > 9 do begin
+      Result := Chr(Ord('0') + (Value mod 10)) + Result;
+      Value := Value div 10;
+    end;
+    Result := '-' + Chr(Ord('0') + (Value mod 10)) + Result;
+  end else begin
+    while Value > 9 do begin
+      Result := Chr(Ord('0') + (Value mod 10)) + Result;
+      Value := Value div 10;
+    end;
+    Result := Chr(Ord('0') + Value) + Result;
+  end;
+end;
+
 { TBigInt }
 
@@ -88 +153 @@
 procedure TBigInt.SetData(Index: TBigIntSize; AValue: Byte);
 begin
-  if Index > Integer(Size) - 1 then Size := Index + 1;
+  if Index >= Integer(Size) then raise Exception.Create(SOutOfRange);
   FData[Index] := AValue;
 end;
@@ -209 +274 @@
 end;
 
+class operator TBigInt.Negative(A: TBigInt): TBigInt;
+begin
+  Result := A.Copy(A.Size);
+  Result.Invert;
+  Result := Result + 1;
+end;
+
 class operator TBigInt.Inc(A: TBigInt): TBigInt;
 begin
@@ -224 +296 @@
   V: SmallInt;
   Carry: Byte;
-begin
-  Result.Size := Max(A.Size, B.Size);
+  Size: Byte;
+begin
+  Size := Max(A.Size, B.Size);
+  Result.Size := Size;
   Carry := 0;
   I := 0;
-  while (I < Result.Size) or (Carry > 0) do begin
+  while (I < Size) or (Carry > 0) do begin
+    if I >= Result.Size then Result.Size := I + 1;
     V := A.Data[I] + B.Data[I] + Carry;
     if V >= 256 then begin
@@ -240 +315 @@
 class operator TBigInt.Subtract(A, B: TBigInt): TBigInt;
 var
-  I: Integer;
-  V: SmallInt;
-  Carry: Byte;
-begin
-  Result.Size := Max(A.Size, B.Size);
-  Carry := 0;
-  I := 0;
-  while (I < Result.Size) or (Carry > 0) do begin
-    V := A.Data[I] - B.Data[I] - Carry;
-    if V < 0 then begin
-      Carry := 1;
-    end else Carry := 0;
-    Result.Data[I] := V and $ff;
-    Inc(I);
-  end;
+  Size: TBigIntSize;
+begin
+  Size := Max(A.Size, B.Size);
+  Result := A + -B;
+  Result.Size := Size;
+  Result.Shrink;
 end;
 
@@ -316 +382 @@
 end;
 
+class operator TBigInt.BitwiseXor(A, B: TBigInt): TBigInt;
+var
+  I: TBigIntSize;
+begin
+  Result.Size := Max(A.Size, B.Size);
+  for I := 0 to Result.Size - 1 do
+    Result.Data[I] := A.Data[I] xor B.Data[I];
+  Result.Shrink;
+end;
+
+class operator TBigInt.BitwiseAnd(A, B: TBigInt): TBigInt;
+var
+  I: TBigIntSize;
+begin
+  Result.Size := Max(A.Size, B.Size);
+  for I := 0 to Result.Size - 1 do
+    Result.Data[I] := A.Data[I] and B.Data[I];
+  Result.Shrink;
+end;
+
+class operator TBigInt.BitwiseOr(A, B: TBigInt): TBigInt;
+var
+  I: TBigIntSize;
+begin
+  Result.Size := Max(A.Size, B.Size);
+  for I := 0 to Result.Size - 1 do
+    Result.Data[I] := A.Data[I] or B.Data[I];
+  Result.Shrink;
+end;
+
+class operator TBigInt.LeftShift(A: TBigInt; B: Integer): TBigInt;
+var
+  ByteShift: TBigIntSize;
+  BitShift: Byte;
+  I: Integer;
+begin
+  if (B and 7) = 0 then begin
+    // Full byte shift
+    ByteShift := B shr 3;
+    Result.Size := A.Size + ByteShift;
+    Move(A.FData[0], Result.FData[ByteShift], A.Size);
+    FillChar(Result.FData[0], ByteShift, 0);
+  end else begin
+    // Partial byte shift
+    ByteShift := B shr 3;
+    BitShift := B - ByteShift;
+    Result.Size := Result.Size + ByteShift + 1;
+    for I := 0 to A.Size - 1 do begin
+      Result.FData[I + ByteShift] := (A.FData[I] shl BitShift) and $ff;
+      if I > 0 then Result.FData[I + ByteShift] := Result.FData[I + ByteShift] or (A.FData[I] shl BitShift shl 8);
+    end;
+  end;
+  Result.Shrink;
+end;
+
+class operator TBigInt.RightShift(A: TBigInt; B: Integer): TBigInt;
+var
+  ByteShift: TBigIntSize;
+  BitShift: Byte;
+  I: Integer;
+begin
+  if (B and 7) = 0 then begin
+    // Full byte shift
+    ByteShift := B shr 3;
+    Result.Size := A.Size - ByteShift;
+    Move(A.FData[ByteShift], Result.FData[0], A.Size);
+  end else begin
+    // Partial byte shift
+    ByteShift := B shr 3;
+    BitShift := B - ByteShift;
+    Result.Size := Result.Size - ByteShift;
+    for I := 0 to A.Size - 1 do begin
+      Result.FData[I] := (A.FData[I + ByteShift] shr BitShift) and $ff;
+      if I < (A.Size - 1) then Result.FData[I] := Result.FData[I] or (((A.FData[I + ByteShift] shl 8) shr BitShift) and $ff);
+    end;
+  end;
+  Result.Shrink;
+end;
+
+class operator TBigInt.Modulus(A, B: TBigInt): TBigInt;
+begin
+
+end;
+
+class operator TBigInt.IntDivide(A, B: TBigInt): TBigInt;
+begin
+
+end;
+
 procedure TBigInt.Shrink;
 var
@@ -346 +501 @@
 begin
   Result := (FData[Size - 1] and $80) = 0;
+end;
+
+procedure TBigInt.Invert;
+var
+  I: Byte;
+begin
+  for I := 0 to Size - 1 do
+    FData[I] := FData[I] xor $ff;
 end;
 
@@ -372 +535 @@
 end;
 
+function TBigInt.Copy: TBigInt;
+begin
+  Result := Copy(Size);
+end;
+
 end.