Exponent aus Extended extrahieren?

[stoxx]

weiß jemand, wie man am schnellsten den Exponent aus einem Extended extrahieren kann?
(am besten als Dezimalzahl)

[jaenicke]

Logarithmus?

[stoxx]

bei "schnell" dachte ich eher an Assembler und SHL Befehle und so ..





ich hab hier auch schon was gefunden.

http://www.delphipraxis.net/internal...light=mantisse


warum muss man erst den Exponent erst mit

if ExtRec(B).Exp and $7FFF = $7FFF then prüfen?

und warum steht da noch?

(ExtRec(B).Exp and $7FFF) - $3FFE - 64;

[himitsu]

schau da mal in der FMath.pas die Functionen FloatConvert an.
http://www.delphipraxis.net/internal...=891540#891540

Code:

Single       8/23
-eEEEEEE EMMMMMMM MMMMMMMM MMMMMMMM

Double      11/52
-eEEEEEE EEEEMMMM MMMMMMMM MMMMMMMM MMMMMMMM MMMMMMMM MMMMMMMM MMMMMMMM

Extended  15+1/63
-eEEEEEE EEEEEEEE SMMMMMMM MMMMMMMM MMMMMMMM MMMMMMMM MMMMMMMM MMMMMMMM MMMMMMMM MMMMMMMM

- Vorzeichen
E Exponent
M Mantisse

je Gruppen á 8 Bit / 1 Byte

[Amateurprofi]

@stoxx:


Zur Frage :
warum muss man erst den Exponent erst mit
if ExtRec(B).Exp and $7FFF = $7FFF then prüfen

Weil, wenn der Exp = $7FFF ist, die Zahl eine NaN (Not a Number) oder Infinite (Unendlich) ist.
Weiter sollte man prüfen, ob beide, Mantisse und Exponent, = 0 sind. Dann ist die Zahl = 0.

[stoxx]

Hi Himitsu,


Du, ich hab mir gerade mal Deine Unit FMath angschaut.
Die ganzen Bitmasken, die Du da gleich vordefinierst, sehen sehr effizent aus.
BitInt Erfahrung hast Du auch noch.

Vielleicht hast Du ja einen guten Tip?

wir haben einen Fixcomma64 Datentyp. Dieser hat hat feste 9 Nachkommastellen. Intern wird es als int64 Wert gespeichert.

wenn man die Zahl z.b. als Double haben möchte, muss man durch den Skalierungsfaktor teilen.
die gespeicherte Zahl ist quasi also immer um 10^9 zu groß ...

Delphi-Quellcode:

// Double
class operator FIXCOMMA64.Implicit(const AValue: FIXCOMMA64) : double;
begin
  Result := AValue.FBCD9 / FBCD9EXT;
end;

Leider ist die Multiplikation um Faktor 10 langsamer als eine reine Double Multiplikation.
Am besten wäre, wir hätten eine MulDiv64 Funktion, aber die hatte ja leider damals nicht funktioniert.
Du hattest Dich auch mal dran versucht, diesen C Quelltext zu übersetzen, weiß nicht, ob Du Dich noch erinnerst.

Die Funktion ist sicher nun viel zu umständlich.
Erst wird das Ergebnis in extended ausgerechnet.
Danach der vorkomma und Nachkomma Anteil getrennt behandelt.
Der Nachkommaanteil wird dann noch gerundet.
Das erfolgt so, in dem mit einem Faktor multipliziert, der um Faktor 10 zu groß als Skalierungsfaktor selbst,
danach wird gerundet und wieder durch 10 dividiert.
das alles dient dazu, um keine Ungenauigkeiten reinzubekommen, wie bei Gleitkommazahlen üblich. funktioniert auch alles soweit.
nur eben seeehr langsam ...
iDiv64 ist aus dem Fastcode projekt ..

jetzt war meine Idee .. man würde jetzt den Exponenten auslesen. Mit einem Faktor a multiplizieren, um zu runden und durch 10 zu dividieren.

der Faktor a müsste nun die Differenz zwischen dem neuen ermitteltem Exponenten und dem Zielexponenten von 10^-9 sein, damit die Zahl als BCD Wert reingeschrieben werden kann.

Fällt Dir vielleicht etwas intelligenteres ein? Vielleicht kannst Du ja mal drüber gucken ! danke Dir schonmal !

Delphi-Quellcode:

//====[  *  ]===================================================================
class operator FIXCOMMA64.Multiply(const Left, Right: FIXCOMMA64): FIXCOMMA64;
var val: extended;
begin

//   FBCD9INT  = 1000000000;
//   FBCD9EXT  = 1000000000.0;
//   FBCD10INT = 10000000000;
//   FBCD10EXT = 10000000000.0;



  val := (Left.FBCD9 / FBCD9EXT) * (Right.FBCD9 / FBCD9EXT);

  Result.FBCD9 := (Trunc(val)*FBCD9INT) + iDIV64(Round(frac(val)*FBCD10EXT), 10);
end;

[himitsu]

Du weißt aber, daß du so über 'nen Extended gehst/rechnest und damit unter Umständen die letze (9.) Kommastelle einbüßt.

In welchem Bereich liegen denn deine Werte?

Wenn die im Bereich -9,223372036854775808 .. 9,223372036854775807 liegen, dann könnte man einfach:

Delphi-Quellcode:

class operator FIXCOMMA64.Multiply(const Left, Right: FIXCOMMA64): FIXCOMMA64;
var val: extended;
begin
  Result.FBCD9 := (Left.FBCD9 * Right.FBCD9 + (FBCD9INT div 2)) div FBCD9INT;
end;

.FBCD9 ist och ein Int64?

Bei größerem Wertebereich müßte am den Überlauf abfangen, also sozusagen die Multiplikation mit 128 Bit-Integern berechnen, bzw. die Berechnung auf 2 64-Bit oder besser noch auf 4 (vier) 3 32-Bit-Integer (für 32-Bit-CPUs) zerlegen.

praktisch so, wie es Delphi schon beim Int64 macht ... nur größer

[stoxx]

Zitat:

Du weißt aber, daß du so über 'nen Extended gehst/rechnest und damit unter Umständen die letze (9.) Kommastelle einbüßt.

ja, deswegen die umständliche seperate Berechnung des Vorkomma und Nachkomma Anteils...

Zitat:

FBCD9 ist och ein Int64?

ja das ist korrekt


die Werte haben folgenden Wertebereich

Delphi-Quellcode:

   FBCD9Min = int64($8000000000000001); // -9223372036.854775807
FBCD9Max = int64($7FFFFFFFffffffff); //  9223372036.854775807

Zitat:

Bei größerem Wertebereich müßte am den Überlauf abfangen, also sozusagen die Multiplikation mit 128 Bit-Integern berechnen, bzw. die Berechnung auf 2 64-Bit oder besser noch auf 4 (vier) 3 32-Bit-Integer (für 32-Bit-CPUs) zerlegen.

ähm

[stoxx]

ich wollte es jetzt mit der Integeraritmetik der FPU probieren, so wie es Currency auch macht, damit scheint es zu funkionieren.
Ich bekomme aber die Variablen bei den Class operatoren nicht in die FPU. Da steht immer Müll im st(0) und st(1).
Weißt Du, wie es geht?

Delphi-Quellcode:

class operator FIXCOMMA64.Multiply(const Left, Right: FIXCOMMA64): FIXCOMMA64;
  asm

    Fild qword ptr [left.FBCD9]
    Fild qword  [right.FBCD9]

[himitsu]

ich glaub ich hab erstmal 'ne Lösung für den Bereich von etwas -96038,388 bis 96038,388 reicht aber aus, da die Multiplication bei rund 9223372036 = 96038*96038 eh einen Überlauf bringt.
(also 'ne Zahl kann natürlich auch größer als 96038,388 sein, wenn der andere Operand entsprechend kleiner ist)

Code:

Result := (left * right) div 1000000000;
          ***überlauf***

Result := left * (right div 1000000000)
  + (left * (right mod 1000000000)) div 1000000000
    ***********überlauf************

Result := left.FBCD9 * (right div 1000000000)
  + ((left mod 1000000000) * (right mod 1000000000)) div 1000000000
  + (left div 1000000000) * (right mod 1000000000);

[s]und mit Runden der 9. Kommastelle (glaub ich)
Result := left.FBCD9 * (right div 1000000000)
  + ((left mod 1000000000) * (right mod 1000000000)) div 1000000000
  + ((left + 500000000) div 1000000000) * (right mod 1000000000);[/s]
[edit] blödsinn

Delphi-Quellcode:

class operator FIXCOMMA64.Multiply(const Left, Right: FIXCOMMA64): FIXCOMMA64;
  begin
    Result.FBCD9 := left.FBCD9 * (right.FBCD9 div 1000000000)
      + ((left.FBCD9 mod 1000000000) * (right.FBCD9 mod 1000000000)) div 1000000000
      + (left.FBCD9 div 1000000000) * (right.FBCD9 mod 1000000000);
  end;

und das Andere

Delphi-Quellcode:

class operator FIXCOMMA64.Multiply(const Left, Right: FIXCOMMA64): FIXCOMMA64;
  const idiv: LongInt = 1000000000;

  asm
    fild qword ptr [&left.FBCD9]
    fild qword ptr [&right.FBCD9]
    fmulp st(1), st(0)
    fidiv dword ptr [&idiv]
    fistp qword ptr [&result.FBCD9]
    wait
  end;

[edit] das mit dem Runden wahr wohl blödsinn ... kommt davon, wenn man das Rechenergebnis mit einem Ergebnis via Floattypen vergleicht und denkt die eigene Rechnung stimme nicht ganz