System.TExtended80Rec
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};
};
Contents
Properties
| Type | Visibility | Source | Unit | Parent |
|---|---|---|---|---|
record struct |
public | System.pas System.hpp |
System | System |
Description
Provides support for manipulating extended precision floating-point values.
A TExtended80Rec can be used to perform low-level operations on an extended precision floating-point value. For example, the sign, the exponent, and the mantissa can be changed separately.
In Delphi on Win32, the Extended data type is 10 bytes. On Win64, however, the Extended data type is only 8 bytes. Using TExtended80Rec on Win64 enables you to perform memory-related operations with 10-bit floating-point variables, but not extended-precision arithmetic operations.
Note:
- To manipulate an 80-bit extended precision floating-point type, it is recommended that you use TExtendedHelper. However, TExtended80Rec is not obsolete, and you can use TExtended80Rec to allocate 80-bit extended data.
- Beginning from XE3, the TExtended80Rec.Bytes and TExtended80Rec.Words properties are array properties. System.High and System.Low operators do not apply for array properties. You can use System.SizeOf instead, as shown in the example in TSingleRec.
Example
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)
// ...
Console output if the size of extended is 10 bytes:
Sign: 1 Exponent: 16389 Mantissa: 849999999999999A Size of Extended: 10 -33.15
Console output if the size of extended is 8 bytes:
Sign: 1 Exponent: 16389 Mantissa: 8499999999999800 Size of Extended: 8 -33.15
The floating-point constant "-66.3" is evaluated as 64-bits precision if the size of the extended type is 80-bit. But if the size of extended is 64-bit, "-66.3" is evaluated as only 53-bit precision even if TExtended80Rec can handle 64-bit. This is the reason why Mantissa (and Fraction) have a difference.