HexToDec optimieren

[himitsu]

Ja, denn er braucht auch mal mehr, als nur 64 Bit.

Binär könnte man das über mehrere Int64 lösen, aber die Umwandlung nach Dezimal wird dann ein bissl umständlicher.

[Mavarik]

Zitat von himitsu:

Ja, denn er braucht auch mal mehr, als nur 64 Bit.

Binär könnte man das über mehrere Int64 lösen, aber die Umwandlung nach Dezimal wird dann ein bissl umständlicher.

OK dann für jeweils 8 Byte erst mal so..
Denke nicht das es noch schneller geht...

Delphi-Quellcode:

function HexToDec(const s: Array of Byte): AnsiString; overload;
//Sehr grosse Hex-Zahlen Decimal umwandeln
{--------------------------------------------------------------}
var
  a : int64;
  b : array[0..3] of word absolute s;
  c : array[0..3] of word absolute a;
begin
  c[3] := swap(b[0]);
  c[2] := swap(b[1]);
  c[1] := swap(b[2]);
  c[0] := swap(b[3]);
  result := inttostr(a);
end;

Mavarik

[Dejan Vu]

Das soll funktionieren, wenn in s ein String aus Hex-Ziffern steht?

Allgemein würde ich mich zunächst auf ein Format für große Zahlen einigen (BigInt, string etc.). Für das entsprechende Format benötigt man dann nur die Addition und Multiplikation.

Der Rest ist doch trivial:

Delphi-Quellcode:

Type
  IBigInteger = interface 
    Procedure Assign (n : Integer);
    Procedure Add (n : Integer);
    Procedure Multiply (n : Integer);
  end;

Function HexToNumber (aHugeHex : Array Of AnsiChar) : IBigInteger;
Var
  i : Integer;

Begin
  result := CoBigInteger.Create;
  result.Assign(0);
  for i:=high(aHugeHex) downto Low(aHugeHex) do begin
    result.Multiply (16);
    result.Add (hexLookup[aHugeHex[i]]);
  end;
  return result;
end;

Wenn ich es nicht komplett verrissen habe, sollte das doch so funktionieren. Zum Testen kann man ja eine Klasse schreiben, die IBigInteger implementiert und das ganze aber für Int64 umsetzt. Wenn das klappt, passt man das für BigInt oder ein eigenes Format an.

[Mavarik]

Zitat von Dejan Vu:

Das soll funktionieren, wenn in s ein String aus Hex-Ziffern steht?

Zitat von Kostas:

Ich benötige die gleiche function nur als weitere Variante die als Parameter ein "Array of Byte" bekommt.

Oder?

[gammatester]

Hier eine alte Routine für wirklich lange Umwandlungen von Bytearrays in Radix-B-Zahlen, schnell aufgebohrt für die Situation hier. Ist etwas allgemeiner da auch andere Ziel-Basen neben 10 nöglich sind.

Delphi-Quellcode:

function base256_to_baseB(var a: array of byte; n: integer;  B: byte): string;
  {-n byte of big-endian base 256 number to base B string, a is destroyed}
const
  cmap: array[0..61] of char = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
var
  i,k,m: integer;
  w: word;
  d: byte;
  s: string;
begin
  s := '';
  {k is index of MSB of a}
  k := low(a);
  m := low(a)+n-1;
  repeat
    {One repeat iteration calculates a := a div B;  d := a mod B}
    {initialize "carry"}
    w := 0;
    for i:=k to m do begin
      {loop invariant: 0 <= w < B}
      w := (w shl 8) or a[i];
      if w>=B then begin
        d := w div B;
        w := w mod B;
      end
      else d:=0;
      a[i] := d;
    end;
    {set d to remainder, w is still < B!}
    d := byte(w);
    {add base R digit to result if d is not out of range}
    if d<sizeof(cmap) then s := cmap[d]+s
    else s := '?'+s;
    {if MSB(a) is zero increment lower bound}
    if a[k]=0 then inc(k);
  until k>m;
  base256_to_baseB := s;
end;

Habe mir nicht die Mühe gemacht, die Routine so zu ändern, daß die Eingabe nicht überschrieben wird. Ein Testprogamm für die Funktion

Delphi-Quellcode:

const
  Test: array[0..24] of byte = (
          $9F,$4F,$27,$26,$17,$9A,$22,$45,$01,$D7,$62,$42,$2C,
          $94,$65,$90,$D9,$10,$00,$00,$00,$00,$00,$00,$2A);
var
  s: string;
  tmp: array[0..100] of byte;
  i: integer;
begin
  {Copy because arg is destroyed}
  for i:=0 to sizeof(Test)-1 do tmp[i] := Test[i];
  s := base256_to_baseB(tmp, sizeof(Test), 10);
  writeln('Decimal number: ', s);
end.

liefert dann Decimal number: 10000000000000000000000000000000000000000000000000 00000000042