IBM Floating Point Architecture

IBM System/360 computers, and subsequent machines based on that architecture (mainframes), support a hexadecimal floating-point format.^[1][2][3]

In comparison to IEEE 754 floating-point, the IBM floating-point format has a longer significand, and a shorter exponent. All IBM floating-point formats have 7 bits of exponent with a bias of 64. The normalized range of representable numbers is from 16⁻⁶⁵ to 16⁶³ (approx. 5.39761 × 10⁻⁷⁹ to 7.237005 × 10⁷⁵).

The number is represented as the following formula: (−1)^sign × 0.significand × 16^{exponent−64}.

Single-precision 32-bit

A single-precision binary floating-point number is stored in a 32-bit word:

1		7			24		(width in bits)
S	Exp			Fraction
31	30	...	24	23	...	0	(bit index)*
* Note that IBM documentation numbers the bits from left to right, so that the most significant bit is designated as bit number 0.

Note that in this format the initial bit is not suppressed, and the radix point is set to the left of the mantissa in increments of 4 bits.

Since the base is 16, the exponent in this form is about twice as large as the equivalent in IEEE 754, in order to have similar exponent range in binary, 9 exponent bits would be required.

Example

Consider encoding the value −118.625 as an IBM single-precision floating-point value.

First note that the value is negative, so the sign bit is 1.

The value 118.625₁₀ in binary is 1110110.101₂. This value is normalized by moving the radix point left four bits (one hexadecimal digit) at a time until the leftmost digit is zero, yielding 0.01110110101₂. The remaining rightmost digits are padded with zeros, yielding a 24-bit fraction of .0111 0110 1010 0000 0000 0000₂.

The normalized value moved the radix point two digits to the left, yielding a multiplier and exponent of 16⁺². A bias of +64 is added to the exponent (+2), yielding +66, which is 100 0010₂.

Combining the sign, exponent plus bias, and normalized fraction produces this encoding:

S	Exp	Fraction
1	100 0010	0111 0110 1010 0000 0000 0000

Largest representable number

S	Exp	Fraction
0	111 1111	1111 1111 1111 1111 1111 1111

The number represented is +0.FFFFFF₁₆ × 16^{127 − 64} = (1 − 16⁻⁶) × 16⁶³ ≈ +7.2370051 × 10⁷⁵

Smallest positive normalized number

S	Exp	Fraction
0	000 0000	0001 0000 0000 0000 0000 0000

The number represented is +0.1₁₆ × 16^{0 − 64} = 16⁻¹ × 16⁻⁶⁴ ≈ +5.397605 × 10⁻⁷⁹

Zero

S	Exp	Fraction
0	000 0000	0000 0000 0000 0000 0000 0000

Zero (0.0) is represented in normalized form as all zero bits, which is arithmetically the value +0.0₁₆ × 16^{0 − 64} = +0 × 16⁻⁶⁴ ≈ +0.000000 × 10⁻⁷⁹ = 0. Given a significand of all-bits zero, any combination of positive or negative sign bit and a non-zero biased exponent will yield a value arithmetically equal to zero. However, the normalized form generated for zero by CPU hardware is all-bits zero. This is true for all three floating-point precision formats.

Precision issues

Since the base is 16, there can be three leading zero bits in the binary significand. That means when the number is converted into binary, there can be as few as 21 bits of precision. Because of the "wobbling precision" effect, this can cause some calculations to be very inaccurate.

A good example of the inaccuracy is representation of decimal value 0.1. It has no exact binary or hexadecimal representation. In hexadecimal format, it is represented as 0.19999999...₁₆ or 0.0001 1001 1001 1001 1001 1001 1001...₂, that is:

S	Exp	Fraction
0	100 0000	0001 1001 1001 1001 1001 1010

This has only 21 bits, whereas the binary version has 24 bits of precision.

Six hexadecimal digits of precision is roughly equivalent to six decimal digits (i.e. (6 − 1) log₁₀(16) ≈ 6.02). A conversion of single precision hexadecimal float to decimal string would require at least 9 significant digits (i.e. 6 log₁₀(16) + 1 ≈ 8.22) in order to convert back to the same hexadecimal float value.

Double-precision 64-bit

Double-precision is the same except that the mantissa (fraction) field is wider and the double-precision number is stored in a double word (8 bytes):

1		7			56		(width in bits)
S	Exp			Fraction
63	62	...	56	55	...	0	(bit index)*
* Note that IBM documentation numbers the bits from left to right, so that the most significant bit is designated as bit number 0.

Note that the exponent range for this format is only about a quarter as large as the corresponding IEEE binary format.

14 hexadecimal digits of precision is roughly equivalent to 17 decimal digits. A conversion of double precision hexadecimal float to decimal string would require at least 18 significant digits in order to convert back to the same hexadecimal float value.

Extended-precision 128-bit

Extended-precision (quadruple-precision) was added to the System/370 series and was available on some S/360 models (S/360-85, -195, and others by special request or simulated by OS software). The extended-precision mantissa (fraction) field is wider, and the extended-precision number is stored as two double words (16 bytes):

High-order part
1		7			56		(width in bits)
S	Exp			Fraction (high-order 14 digits)
127	126	...	120	119	...	64	(bit index)*
Low-order part
8					56		(width in bits)
Unused				Fraction (low-order 14 digits)
63	...		56	55	...	0	(bit index)*
* Note that IBM documentation numbers the bits from left to right, so that the most significant bit is designated as bit number 0.

28 hexadecimal digits of precision is roughly equivalent to 32 decimal digits. A conversion of extended precision hexadecimal float to decimal string would require at least 35 significant digits in order to convert back to the same hexadecimal float value.

Arithmetic operations

Most arithmetic operations truncate like simple pocket calculators. Therefore, 1 − 16⁻⁷ = 1. In this case, the result is rounded away from zero.^[4]

IEEE 754 on IBM mainframes

Starting with the S/390 G5 in 1998,^[5] IBM mainframes have also included IEEE binary floating-point units which conform to the IEEE 754 Standard for Floating-Point Arithmetic. IEEE decimal floating-point was added to IBM System z9 GA2^[6] in 2007 using millicode^[7] and in 2008 to the IBM System z10 in hardware.^[8]

Modern IBM mainframes support three floating-point radices with 3 hexadecimal (HFP) formats, 3 binary (BFP) formats, and 3 decimal (DFP) formats. There are two floating-point units per core; one supporting HFP and BFP, and one supporting DFP; note there is one register file, FPRs, which holds all 3 formats.

Special uses

The IBM floating-point format is used in:

• SAS 5 Transport files (.XPT) as required by the Food and Drug Administration (FDA) for New Drug Application (NDA) study submissions^[9]
• GRIB (GRIdded Binary) data files to exchange the output of weather prediction models (IEEE single-precision floating-point format in current version),
• GDS II (Graphic Database System II) format files (OASIS is the replacement), and
• SEG Y (Society of Exploration Geophysicists Y) format files (single-precision floating-point was added to the format in 2002).^[10]

As IBM is the only remaining provider of hardware (and only in their mainframes) using their non-standard floating-point format, no popular file format requires it; Except the FDA requires the SAS file format and "All floating-point numbers in the file are stored using the IBM mainframe representation. [..] Most platforms use the IEEE representation for floating-point numbers. [..] To assist you in reading and/or writing transport files, we are providing routines to convert from IEEE representation (either big endian or little endian) to transport representation and back again."^[9] Code for IBM's format is also available under LGPLv2.1.^[11]

Systems that use the IBM floating-point format

• IBM System/360
• RCA Spectra 70
• English Electric System 4
• GEC 4000 series minicomputers
• Interdata 16-bit and 32-bit computers
• Texas Instruments 990/12

See also

• IEEE 754 Standard for Floating-Point Arithmetic
• Microsoft Binary Format

References

1. IBM System/360 Principles of Operation, IBM Publication A22-6821-6, Seventh Edition (January 13, 1967), pp.41-50
2. IBM System/370 Principles of Operation, IBM Publication GA22-7000-4, Fifth Edition (September 1, 1975), pp.157-170
3. z/Architecture Principles of Operation, IBM Publication SA22-7832-01, Second Edition (October, 2001), chapter 9 ff.
4. ESA/390 Enhanced Floating Point Support: An Overview
5. Schwarz, E. M.; Krygowski, C. A. (September 1999). "The S/390 G5 floating-point unit". IBM Journal of Research and Development. 43 (5.6): 707–721. doi:10.1147/rd.435.0707.
6. Duale, A. Y.; Decker, M. H.; Zipperer, H. -G.; Aharoni, M.; Bohizic, T. J. (January 2007). "Decimal floating-point in z9: An implementation and testing perspective". IBM Journal of Research and Development. 51 (1.2): 217–227. doi:10.1147/rd.511.0217.
7. Heller, L. C.; Farrell, M. S. (May 2004). "Millicode in an IBM zSeries processor". IBM Journal of Research and Development. 48 (3.4): 425–434. doi:10.1147/rd.483.0425.
8. Schwarz, E. M.; Kapernick, J. S.; Cowlishaw, M. F. (January 2009). "Decimal floating-point support on the IBM System z10 processor". IBM Journal of Research and Development. 53 (1): 4:1–4:10. doi:10.1147/JRD.2009.5388585.
9. "The Record Layout of a Data Set in SAS Transport (XPORT) Format" (PDF). Retrieved September 18, 2014.,
10. http://www.seg.org/documents/10161/77915/seg_y_rev1.pdf
11. https://cran.r-project.org/web/packages/SASxport/SASxport.pdf

Further reading

• Sweeney, D. W. (1965). "An analysis of floating-point addition". IBM Systems Journal. 4 (1): 31–42. doi:10.1147/sj.41.0031.
• Tomayko, J. (Summer 1995). "System 360 Floating-Point Problems". IEEE Annals of the History of Computing. 17 (2): 62–63. doi:10.1109/MAHC.1995.10006. ISSN 1058-6180.
• Harding, L. J. (1966), "Idiosyncrasies of System/360 Floating-Point", Proceedings of SHARE 27, Aug. 8–12 1966, Presented at SHARE XXVII, Toronto, Canada
• Harding, L. J. (1966), "Modifications of System/360 Floating Point", SHARE Secretary Distribution, pp. 11–27, SSD 157, C4470
• Anderson, S. F.; Earle, J. G.; Goldschmidt, R. E.; Powers, D. M. (January 1967). "The IBM System/360 Model 91: Floating-Point Execution Unit". IBM Journal of Research and Development. 11 (1): 34–53. doi:10.1147/rd.111.0034.
• Padegs, A. (1968). "Structural aspects of the System/360 Model 85, III: Extensions to floating-point architecture". IBM Systems Journal. 7 (1): 22–29. doi:10.1147/sj.71.0022.
• Schwarz, E. M.; Sigal, L.; McPherson, T. J. (July 1997). "CMOS floating-point unit for the S/390 Parallel Enterprise Server G4". IBM Journal of Research and Development. 41 (4.5): 475–488. doi:10.1147/rd.414.0475.