IEEE 754 formats: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		`single`, `double` and `extended` are [[FPC]]'s [[Data type\|data types]] implementing [[Pascal]]’s [[Real\|real]]. All of them are implemented according IEEE standard 754, where `single` is “single-precision”, `double` is “double-precision”, and `extended` has 80 bits.
2	2
3	3		## `single`
4	4
5	5		\| \| \|
6	6		\|----\|----\|
7	7		\| value range \| 1.5E-45 .. 3.4E38 \|
8	8		\| accuracy \| 6-9 significant decimal digits precision \|
9	9		\| memory requirement \| 4 bytes or [[32 bit\|32 bits]] \|
10	10		\| property \| The single- data-type data field can hold floating-point values and signed and unsigned integer values. Assigning other values will result in error messages from the compiler when the program is compiled, and the compile will be aborted. That is, the executable program is not created. \|
11	11
12	12		Definition of a data field of data type Single:
13	13
14	14		``` pascal
15	15		var
16	16		s: single;
17	17		```
18	18
19	19		Examples of assigning valid values:
20	20
21	21		``` pascal
22	22		s := -123.45678;
23	23		// Note: '0' is an integer literal. 0.0 is an real literal.
24	24		// Here, FPC will make an implicit typecast from integer to single:
25	25		s := 0;
26	26		// a positive sign is optional
27	27		s := 123.45678;
28	28		```
29	29
30	30		Examples of assigning invalid values:
31	31
32	32		```text
33	33		s := '-123.45678';
34	34		s := '0';
35	35		s := '123.45678';
36	36		```
37	37
38	38		The difference between the two examples is that the upper example is the assignment of Integer and Floating literals, while the assignment of the lower example is literals of the String type.
39	39
40	40		### Binary floating-point format
41	41
42	42		Any value stored as a single requires 32 bits, formatted as shown in the table below:
43	43
44	44		\| Bits \| Usage \|
45	45		\|----------\|-----------------------------------\|
46	46		\| 31 \| Sign (0 = positive, 1 = negative) \|
47	47		\| 30 to 23 \| Exponent, biased by 127 \|
48	48		\| 22 to 0 \| Fraction f of the number 1.f \|
49	49
50	50		## `double`
51	51
52	52		Any value stored as a double requires 64 bits, formatted as shown in the table below:
53	53
54	54		\| Bits \| Usage \|
55	55		\|----------\|-----------------------------------\|
56	56		\| 63 \| Sign (0 = positive, 1 = negative) \|
57	57		\| 62 to 52 \| Exponent, biased by 1023 \|
58	58		\| 51 to 0 \| Fraction f of the number 1.f \|
59	59
60	60		Example of converting from raw data to double (Data is `array [0..7] of byte`):
61	61
62	62		``` pascal
63	63		function ToDouble(const Data; IntelEndianness: Boolean = False):Double;inline;
64	64		var
65	65		ADouble: Double absolute Data;
66	66		AQWord: QWord absolute Result;
67	67		begin
68	68		Result := ADouble;
69	69		if not IntelEndianness then
70	70		AQWord := SwapEndian(AQWord);
71	71		end;
72	72		```
73	73
74	74		## `extended`
75	75
76		-	`extended` is a 80-bit wide floating-point data type. There are <abbr title="floating-point unit">FPU</abbr>s that internally use 80 bits for increased precision. FPC allows to use this gain in precision.
	76	+	`extended` is a 80-bit wide floating-point data type. There are FPUs that internally use 80 bits for increased precision. FPC allows to use this gain in precision.
77	77
78	78		> Note: If some platform does not support the `extended` data type, it will be mapped to largest available floating-point number data available, i. e. usually `double`.
79	79
80	80		## Using the maximum precision for constants
81	81
82	82		In this example:
83	83
84	84		``` pascal
85	85		var
86	86		f: double;
87	87		n: integer = 1758;
88	88		m: integer = 0;
89	89		begin
90	90		f := n * 1.2E6 + (2m+1) 50E3; // 2109650048
91	91		```
92	92
93	93		FPC will interpret the constant `1.2E6` as `Single` type, because it fits into the range of the `Single` type. This leads to some precision loss in the calculation: the result is 2109650048 instead of 2109650000.
94	94
95	95		You can use the FPC command-line flag `-CF64` to force floating point constants to have at least 64 bits precision. Or you can use `{$MINFPCONSTPREC <n>}` to force the compiler to evaluate all floating point constants always with the precision given by \<n\> = `32`, `64` or `DEFAULT` (`80` is not supported for implementation reasons). In FPC v3.3.1+, you can also use the directive `{$excessprecision on}` which exists also in Delphi.
96	96
97	97		---
98	98		From the Free Pascal wiki, page "IEEE 754 formats", as it stood on 2023-04-05 after a change by Wp, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history