Hex-Wert in Delphi übernehmen

[RWarnecke]

Hallo zusammen,

ich möchte ein Python Script nach Delphi übersetzen. Das funktioniert auch soweit sehr gut. Ich habe nur ein Problem mit dem folgenden Hex-Wert

Zitat:

0x00000000ffff000000000000000000000000000000000000 0000000000000000

Wenn ich den oben genannten Wert in Python über Print ausgebe, erhalte ich folgendes :

Zitat:

Target : 6.34309482461e+57

Wie muss ich in Delphi den Hex-Wert übergeben, damit ich das gleiche Ergebnis erhalte wie in Python ?

[Furtbichler]

Floating point, d.h. double vielleicht?

[RWarnecke]

Wie soll mir das weiterhelfen ? Ich verstehe Deinen Post nicht.

[mkinzler]

Die Anzeige deutet auf einen Hexwert hin.
Du musst den Hexstring wohl zerlegen, um ihn in einen Float zu wandeln.
Oder auf dem Umweg über einen Dezimalstring:
http://stackoverflow.com/questions/2...back-in-delphi

[Der schöne Günther]

Nix verstehen.

Floats sind hier nicht im Spiel:

Zitat:

A hexadecimal string takes the form:

Code:

[sign] ['0x'] integer ['.' fraction] ['p' exponent]

( http://docs.python.org/2/library/std...html#float.hex )

Das sind doch normale Ganzzahlen (verdammt große), oder?

Passt das überhaupt noch in einen Int64?

[jaenicke]

Zitat von Der schöne Günther:

Passt das überhaupt noch in einen Int64?

Würde es, aber wie man auf 6.34309482461e+57 kommen könnte, wenn im Wert nur 0xffff, sprich 65535, vorkommt, sehe ich auch nicht.
Hinter dem Wert kommen noch 52 Nullen, mit 53 würde es fast hinkommen, aber das Leerzeichen in dem Wert irritiert mich.

[RWarnecke]

Zitat von jaenicke:

..., aber das Leerzeichen in dem Wert irritiert mich.

Dass hat der Quote-Tag hier im Forum verursacht.

Ich verstehe irgendwie immer noch nichts. Kann mir bitte jemand anhand eines Beispiels erklären, wie ich den Hex-Wert in einer Berechnung übergeben muss ?

[jaenicke]

Also eigentlich sieht der Wert für mich aus wie:

Delphi-Quellcode:

const
  a: Double = $00000000ffff * 10000000000000000000000000000000000000000000000000000.0;
// bzw.
const
  a: Double = $00000000ffff * 1E52;

Aber das sind ja 6,5535E56.

[Medium]

Der Wert ist ein riesen Otto, der geht gewiss nicht in einen Int64.
0000 0000 ffff 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000
32 Bit + 32 Bit + 32 Bit + 32 Bit + 32 Bit + 32 Bit + 32 Bit + 32 Bit
= 256 Bit

(@jaenicke: Warum sollten die Nullen nach den F's auf ein Mal dezimal sein?)

Da Delphi keinen 256 Bit Integer kennt, bleibt nur die Umwandlung in einen Fließkommawert, wobei aber Genauigkeit flöten geht. Potenziell hier sogar ohne viel Verlust (zumindest binär gesehen) wegen der vielen Nullen hinten dran. Die Ausgabe von Python deutet z.B. darauf hin, dass der Wert zumindest für die Anzeige ein Mal durch einen Float-Wert geschleift wurde. Ob das so gehört, oder eine Grenze von Python ist, weiss ich nicht. Ich weiss nur, dass man ohne 3rd Party Libs bzw. entsprechende Handarbeit solche Werte nicht einfach so in einem Delphiprogramm nutzen kann - ausser eben wie o.g. als Fließkommazahl. Ob das in dem Fall eine Option ist, hängt davon ab was damit nachher noch alles passieren muss, das können wir hier nicht einschätzen.

[Furtbichler]

Zitat von RWarnecke:

Wie soll mir das weiterhelfen ? Ich verstehe Deinen Post nicht.

So:

Delphi-Quellcode:

Type
  TDoubleConversion = record
    case boolean of
      false : (asDouble : Double);
      true  : (asBytes : Array [0..7] Of Byte);
  End;

var
  X : TDoubleConversion;

Begin
  x.AsBytes := HexStringToByteArray(yourHexStringHere);
  writeln(x.asDouble);
End;

Aber es sind ja 16 Bytes (war vorhin zu faul zum lesen, mal wieder). Ergo vielleicht so

Delphi-Quellcode:

  TExtendedConversion = record
    case boolean of
      false : (asExtended : Extended);
      true  : (asBytes : Array [0..15] Of Byte);
  End;