Syntax

type Extended;

Description

The Extended type is an Intel standard floating-point type that uses 10 bytes to store a sign bit, a 15-bit exponent, and a 64-bit mantissa. Extended conforms to the minimum requirements of the IEEE-754 extended double precision type.

The limits of the Extended type are approximately 3.37 × 10^-4932 to 1.18 × 10⁴⁹³², with about 19 decimal digits of precision.

Unlike Single and Double, Extended contains all of its significant bits. Normalized values, infinity, and not-a-number have an explicit 1 bit as the most significant bit. Table 5-2 shows the detailed format of finite and special Extended values. Not all bit patterns are valid Extended values. Delphi raises runtime error 6 (EInvalidOp) if you try to use an invalid bit pattern as a floating-point number.

Tips and Tricks

Example

type
  TExtended = packed record
    case Integer of
    0: (Float: Extended;);
    1: (Bytes: array[0..9] of Byte;);
    2: (Words: array[0..4] of Word;);
    3: (LongWords: array[0..1] of LongWord; LWExtra: Word;);
    4: (Int64s: array[0..0] of Int64; Exponent: Word;);
  end;
  TFloatClass = (fcPosNorm, fcNegNorm, fcPosDenorm, fcNegDenorm,
            fcPosZero, fcNegZero, fcPosInf, fcNegInf, fcQNaN, fcSNan);

// Return the class of a floating-point number: finite, infinity,
// not-a-number; also positive or negative, normalized or denormalized.
// Determine the class by examining the exponent, sign bit, and
// mantissa separately.
function fp_class(X: Extended): TFloatClass; overload;
var
  XParts: TExtended absolute X;
  Negative: Boolean;
  Exponent: LongWord;
  Mantissa: Int64;
begin
  Negative := (XParts.Exponent and $8000) <> 0;
  Exponent :=  XParts.Exponent and $7FFF;
  Mantissa :=  XParts.Int64s[0];

  // The first three cases can be positive or negative.
  // Assume positive, and test the sign bit later.
  if (Exponent = 0) and (Mantissa = 0) then
    // Mantissa and exponent are both zero, so the number is zero.
    Result := fcPosZero
  else if (Exponent = 0) and (Mantissa < 0) then
    // If the exponent is zero, and the mantissa has a 0 MSbit,
    // the number is denormalized. Note that Extended explicitly
    // stores the 1 MSBit (unlike Single and Double).
    Result := fcPosDenorm
  else if Exponent <> $7FFF then
    // Otherwise, if the exponent is not all 1,
    // the number is normalized.
    Result := fcPosNorm
  else if Mantissa = $8000000000000000 then
    // Exponent is all 1, and mantissa has 1 MSBit means infinity.
    Result := fcPosInf

  else
  begin
    // Exponent is all 1, and mantissa is non-zero, so the value
    // is not a number. Test for quiet or signaling NaN. MSBit is
    // always 1. The next bit is 1 for quiet or 0 for signaling.
    if (Mantissa and $4000000000000000) <> 0 then
      Result := fcQNaN
    else
      Result := fcSNaN;
    Exit; // Do not distinguish negative NaNs.
  end;

  if Negative then
    Inc(Result);
end;

See Also