System.TExtended80Rec

Aus RAD Studio API Documentation
Wechseln zu: Navigation, Suche

Delphi

  TExtended80Rec = packed record
  private
{$IFDEF EXTENDEDIS10BYTES}
    aExtended80: Extended;
{$ELSE  !EXTENDEDIS10BYTES}
    aExtended80Frac: UInt64;
    aExtended80Exp:  UInt16;
{$ENDIF !EXTENDEDIS10BYTES}
    function InternalGetBytes(Index: Cardinal): UInt8; inline;
    function InternalGetWords(Index: Cardinal): UInt16; inline;
    procedure InternalSetBytes(Index: Cardinal; const Value: UInt8); inline;
    procedure InternalSetWords(Index: Cardinal; const Value: UInt16); inline;
    function GetBytes(Index: Cardinal): UInt8;
    function GetWords(Index: Cardinal): UInt16;
    function Get_Exp: UInt64; inline;
    function GetExp: UInt64; inline;
    function GetFrac: UInt64; inline;
    function GetSign: Boolean; inline;
    procedure SetBytes(Index: Cardinal; const Value: UInt8);
    procedure SetWords(Index: Cardinal; const Value: UInt16);
    procedure Set_Exp(NewExp: UInt64); inline;
    procedure SetExp(NewExp: UInt64);
    procedure SetFrac(NewFrac: UInt64); inline;
    procedure SetSign(NewSign: Boolean);
  public
    function Exponent: Integer;
    function Fraction: Extended;
    function Mantissa: UInt64; inline;
    property Sign: Boolean read GetSign write SetSign;
    property Exp: UInt64 read GetExp write SetExp;
    property _Exp: UInt64 read Get_Exp write Set_Exp;
    property Frac: UInt64 read GetFrac write SetFrac;
    function SpecialType: TFloatSpecial;
    procedure BuildUp(const SignFlag: Boolean; const Mantissa: UInt64; const Exponent: Integer);
    class operator Explicit(a: Extended): TExtended80Rec;
    class operator Explicit(a: TExtended80Rec): Extended;
    property Bytes[Index: Cardinal]: UInt8 read GetBytes write SetBytes;  // 0..9
    property Words[Index: Cardinal]: UInt16 read GetWords write SetWords; // 0..4
  end;

C++

struct DECLSPEC_DRECORD TExtended80Rec
{
private:
#ifndef _WIN64
    Extended aExtended80;
#else /* _WIN64 */
    unsigned __int64 aExtended80Frac;
    Word aExtended80Exp;
#endif /* _WIN64 */
    Byte __fastcall InternalGetBytes(unsigned Index);
    Word __fastcall InternalGetWords(unsigned Index);
    void __fastcall InternalSetBytes(unsigned Index, const Byte Value);
    void __fastcall InternalSetWords(unsigned Index, const Word Value);
    Byte __fastcall GetBytes(unsigned Index);
    Word __fastcall GetWords(unsigned Index);
    unsigned __int64 __fastcall Get_Exp(void);
    unsigned __int64 __fastcall GetExp(void);
    unsigned __int64 __fastcall GetFrac(void);
    bool __fastcall GetSign(void);
    void __fastcall SetBytes(unsigned Index, const Byte Value);
    void __fastcall SetWords(unsigned Index, const Word Value);
    void __fastcall Set_Exp(unsigned __int64 NewExp);
    void __fastcall SetExp(unsigned __int64 NewExp);
    void __fastcall SetFrac(unsigned __int64 NewFrac);
    void __fastcall SetSign(bool NewSign);
public:
    int __fastcall Exponent(void);
    Extended __fastcall Fraction(void);
    unsigned __int64 __fastcall Mantissa(void);
    __property bool Sign = {read=GetSign, write=SetSign};
    __property unsigned __int64 Exp = {read=GetExp, write=SetExp};
    __property unsigned __int64 _Exp = {read=Get_Exp, write=Set_Exp};
    __property unsigned __int64 Frac = {read=GetFrac, write=SetFrac};
    TFloatSpecial __fastcall SpecialType(void);
    void __fastcall BuildUp(const bool SignFlag, const unsigned __int64 Mantissa, const int Exponent);
    static TExtended80Rec __fastcall _op_Explicit(Extended a);
    __property Byte Bytes[unsigned Index] = {read=GetBytes, write=SetBytes};
    __property Word Words[unsigned Index] = {read=GetWords, write=SetWords};
};

Eigenschaften

Typ Sichtbarkeit Quelle Unit Übergeordnet
record
struct
public
System.pas
System.hpp
System System


Beschreibung

Stellt die Unterstützung für die Bearbeitung von Gleitkommawerten mit der Genauigkeit "extended" bereit.

Mit TExtended80Rec können Low-Level-Operationen mit Gleitkommawerten mit der Genauigkeit "extended" durchgeführt werden. Beispielsweise können das Vorzeichen, der Exponent und die Mantisse separat geändert werden.

In Delphi unter Win32 ist der Extended-Datentyp 10 Byte groß. Unter Win64 ist der Extended-Datentyp jedoch nur 8 Byte groß. TExtended80Rec ermöglicht unter Win64 die Durchführung von speicherbezogenen Operationen mit 10-Bit-Gleitkommavariablen, aber keine arithmetischen Operationen mit der Genauigkeit "extended".

Hinweis:

Beispiel

 
var
  F: TExtended80Rec;
  E: Extended;
  I: Integer;
const
  TAB = Chr(9);
begin
  F := TExtended80Rec(-66.3);

  Writeln('Sign: ' + TAB + TAB + IntToStr(Integer(F.Sign)));
  Writeln('Exponent: ' + TAB + IntToStr(Integer(F.Exp)));
  Writeln('Mantissa: ' + TAB + IntToHex(UInt64(F.Mantissa), 16));

  // Subtract 1 from exponent
  // This is equivalent with division by 2
  F.Exp := F.Exp - 1;

  E := Extended(F);
  Writeln('Size of Extended: ' + TAB + IntToStr(SizeOf(E))); // displays 10 on Win32 and 8 on Win64
  Writeln(FloatToStr(E)); // displays -33.15 (-66.3 / 2)

  // ...

Konsolenausgabe, wenn die Größe von "extended" 10 Byte ist:

Sign:          1
Exponent:       16389
Mantissa:       849999999999999A
Size of Extended:       10
-33.15

Konsolenausgabe, wenn die Größe von "extended" 8 Byte ist:

Sign:          1
Exponent:       16389
Mantissa:       8499999999999800
Size of Extended:       8
-33.15

Die Gleitkommakonstante "-66,3" wird mit einer Genauigkeit von 64 Bit ausgewertet, wenn die Größe des "extended"-Typs 80 Bit beträgt. Bei einer Größe von 64 Bit wird "-66,3" aber nur mit einer Genauigkeit von 53 Bit ausgewertet, auch wenn TExtended80Rec 64 Bit behandeln kann. Das ist der Grund, warum Mantissa (und Fraction) unterschiedlich sind.


Siehe auch