Exponent aus Extended extrahieren?

[stoxx]

ich habs jetzt so:
aber leider funktioniert: Fild qword ptr [&left.FBCD9]
nicht. Da muss bei Class Operatoren irgendwas anderes übergeben werden.
Auch dem Result kann man nix geben ..

Delphi-Quellcode:

//====[  *  ]===================================================================
class operator FIXCOMMA64.Multiply(const Left, Right: FIXCOMMA64): FIXCOMMA64;
const I10     : LongInt  =         10;
      BCD8INT  : LongInt = 100000000;
var
  // val: extended;
  f1, f2 : int64;
begin
//  Result.MaxValue
//  val := (Left.FBCD9 / FBCD9EXT) * (Right.FBCD9 / FBCD9EXT);
//
//  Result.FBCD9 := (Trunc(val)*FBCD9INT) + iDIV64(Round(frac(val)*FBCD10EXT), 10);
//
//exit;

  f1 := left.fbcd9;
  f2 := Right.fbcd9;
  asm
    //    FILD I10
    //    FILD BCD8INT
    Fild qword ptr [f1]
    Fild qword  ptr [f2]
    //    Fild qword ptr [&left.FBCD9]
    //    Fild qword  ptr [&right.FBCD9]
    fmulp st(1),st(0)
    //  FDIVR
    fidiv dword ptr [&BCD8INT]
    FRNDINT
    //  FDIVR
    fidiv dword ptr [&I10]
    FISTP qword  [f1]
    wait
  end;
  Result.FBCD9 := f1;
end;

so ist der definiert:

Delphi-Quellcode:

type PFIXCOMMA64 = ^FIXCOMMA64;  FIXCOMMA64 = packed record
strict private
    FBCD9: int64;
    class function Get_MinValue: FIXCOMMA64; static;
    class function Get_MaxValue: FIXCOMMA64; static;
  private
    function Get_DWORD: DWORD;
    function Get_Int64: Int64;
....

[himitsu]

also hier (D2009)ging das so,

wobei die direkte Integerversion doch eigentlich das Bessere sein sollte?

da es sich von den Speicheradressen nix nimmt, sollte es auch so gehn
und bei mir geht es auch.

Delphi-Quellcode:

uses Math;

type PFIXCOMMA64 = ^FIXCOMMA64;
  FIXCOMMA64 = packed record
    strict private
      FBCD9: int64;
    private
    public
      class operator implicit(const float: Extended): FIXCOMMA64;
      class operator implicit(const rect:  FIXCOMMA64): Extended;
      class operator Multiply(const Left, Right: FIXCOMMA64): FIXCOMMA64;
    end;

class operator FIXCOMMA64.implicit(const float: Extended): FIXCOMMA64;
  begin
    Result.FBCD9 := Round(float * 1000000000);
  end;

class operator FIXCOMMA64.implicit(const rect:  FIXCOMMA64): Extended;
  begin
    Result := rect.FBCD9 / 1000000000;
  end;

class operator FIXCOMMA64.Multiply(const Left, Right: FIXCOMMA64): FIXCOMMA64;
  const 
    idiv: LongInt = 1000000000;
  asm
    fild qword ptr [&left]
    fild qword ptr [&right]
    fmulp st(1), st(0)
    fidiv dword ptr [&idiv]
    fistp qword ptr [&result]
    wait
  end;

procedure TForm2.FormCreate(Sender: TObject);
  var 
    f1, f2, f3: FIXCOMMA64;
  begin
    f1 := 1234.56789;
    f2 := 9876.54321;
    f3 := f1 * f2;
    if SameValue(f3, 12193263.111, 0.001) then
      Beep;
  end;

[stoxx]

hm .. also in D2007 geht das so nicht, naja . .muss man halt die 3 Kopien verkraften



aber nun zurück nochmal zu meiner Ausgangsfrage
Ziel ist es eigentlich, von dem Fixcomma wegzukommen und Double umzustellen, der bei jeder Multiplikation gerundet wird.
Damit man dann eben Gleitkommazahlen doch vergleichen kann.
Dazu brauchte ich den Exponent .. Jetzt meine Frage bezieht sich der Exponent im Double oder Extended auf Binärsystem oder Dezimalsystem.
also sagt die Zahl aus, wo das komma im Binärsystem verrutscht ist .. also da könnte ja die Zahl sehr groß seinn?
Oder entspricht es der Exponentialdarstellung, im Dezimalsystem.
Und wenn nein, wie kommt man dann auf 1.12323 E18 ohne nun mit FormatFloat erst den String rauszuholen um zu gucken?
da bin ich etwas überfragt ...

[himitsu]

und so?

Delphi-Quellcode:

class operator FIXCOMMA64.Multiply(const Left, Right: FIXCOMMA64): FIXCOMMA64;
  const
    idiv: LongInt = 1000000000;
  asm
    mov eax, &Left
    fild qword ptr [eax]
    mov eax, &Right
    fild qword ptr [eax]
    fmulp st(1), st(0)
    fidiv dword ptr [&idiv]
    mov eax, &Result
    fistp qword ptr [eax]
    wait
  end;

[stoxx]

Delphi-Quellcode:

asm
    fild qword  [eax]
    fild qword  [edx]
    fmulp st(1),st(0)
    fidiv dword ptr [&BCD8INT]
    FRNDINT
    fidiv dword ptr [&I10]
    FISTP qword  [ecx]
    wait
end;

Result entspricht dem ecx ? funktionieren tut es zumindest, aber liegt das result nicht immer auf eax?
Ist das jetzt ein Problem da? liegt bei D2009 das ergebnis immer noch auf ecx?

und darf man eax und edx nehmen?
ich frage mich jetzt, ob eax immer 64 Bit groß ist? oder nur auf einem 64 Bit Prozessor?

[himitsu]

in EAX ist hier nur der Pointer zu dem Record

EAX = 32 Bit
AX = 16 Bit
AL 8 Bit

[Amateurprofi]

Zitat von stoxx:

ich frage mich jetzt, ob eax immer 64 Bit groß ist? oder nur auf einem 64 Bit Prozessor?

Und ergänzemd zu himitsus Beitrag:

EAX ist immer ein 32 Bit Register.
Im 64 Bit-Mode gibt es 64 Bit Register (RAX, RBX, RCX, etc.) deren untere 32 Bits mit EAX, EBX, ECX, etc. angesprochen werden können.

Hier zur Info aus Intels Basic Architecture eine Aufstellung der Register im 64 Bit Mode

3.7.2.1 Register Operands in 64-Bit Mode
Register operands in 64-bit mode can be any of the following:
• 64-bit general-purpose registers (RAX, RBX, RCX, RDX, RSI, RDI, RSP, RBP, or R8-R15)
• 32-bit general-purpose registers (EAX, EBX, ECX, EDX, ESI, EDI, ESP, EBP, or R8D-R15D)
• 16-bit general-purpose registers (AX, BX, CX, DX, SI, DI, SP, BP, or R8W-R15W)
• 8-bit general-purpose registers: AL, BL, CL, DL, SIL, DIL, SPL, BPL, and R8LR15L are available using REX prefixes; AL, BL, CL, DL, AH, BH, CH, DH are available without using REX prefixes.
• Segment registers (CS, DS, SS, ES, FS, and GS)
• RFLAGS register
• x87 FPU registers (ST0 through ST7, status word, control word, tag word, data operand pointer, and instruction pointer)
• MMX registers (MM0 through MM7)
• XMM registers (XMM0 through XMM15) and the MXCSR register
• Control registers (CR0, CR2, CR3, CR4, and CR8) and system table pointer registers (GDTR, LDTR, IDTR, and task register)
• Debug registers (DR0, DR1, DR2, DR3, DR6, and DR7)
• MSR registers
• RDX:RAX register pair representing a 128-bit operand

[himitsu]

Und der Grund, warum die Register unverändert sind/bleiben;
der selbe ASM-Code soll natürlich überall das Selbe machen.

was als R (bei RAX) und Co. bei 64 Bit steht, wußte ich jetzt noch nicht ... hatte nie die Zeit und Intention mal danach zu sehen , außerdem ist Commodore (das 64Bit-Delphi) ja noch nicht draußen

[stoxx]

Zitat von Amateurprofi:

Und ergänzemd zu himitsus Beitrag:

EAX ist immer ein 32 Bit Register.
Im 64 Bit-Mode gibt es 64 Bit Register (RAX, RBX, RCX, etc.) deren untere 32 Bits mit EAX, EBX, ECX, etc. angesprochen werden können.

ah, jetzt wird einiges klarer Danke ..