Our technical help group not too long ago acquired a request for a device that may convert IBM System/360 hexadecimal floating level numbers to the IEEE-754 format. I’m most likely the one one left at MathWorks that really used IBM mainframe computer systems. I believed we had seen the final of hexadecimal arithmetic years in the past. However, it seems that the hexadecimal floating level format is alive and properly.
Contents
IBM System/360
The System/360 is a household of mainframe computer systems that IBM launched in 1965 and that dominated the pc business till PCs got here alongside twenty years later. They vary in dimension from desk-sized to programs that fill a big room.
Right here is a photograph of a mid-sized mannequin.
System/360, Mannequin 60. Picture from Ken Shirrif’s weblog, IBM 360/System Abstract.
The System/360 structure is byte-oriented, so it could actually deal with enterprise knowledge processing in addition to scientific and engineering computation. This results in base-16, relatively than base-2 or base-10, floating level arithmetic.
* Binary f*2^e 1/2<=f<1 * Decimal f*10^e 1/10<=f<1 * Hexadecimal f*16^e 1/16<=f<1
Codecs
Floating level codecs performed an vital function in technical computing within the early days. This desk from FMM lists codecs that have been in use within the Nineteen Seventies, earlier than IEEE-754 was launched in 1985.
Information
The System/360 hexadecimal format is utilized in many industries for the preservation of knowledge information.
CREWES. Educating exploration seismology. Complete MATLAB toolbox to be used with the textbook “Numerical Strategies of Exploration Seismology with algorithms in Matlab” by Gary F. Margrave, a geoscience professor on the College of Calgary.
Library of Congress. Authorities.
NASA. Astronautics.
SAS. Statistics and enterprise analytics. SAS wrapers for C.
Enthought. Python wrappers for C.
Hex_ieee
Hex_ieee. I’ve two twenty-line MATLAB capabilities, ieee2ibm and ibm2ieee, that convert IEEE-754 floating level to and from IBM hexadecimal format.
Three statements in the course of ieee2ibm are the important thing to the complete operation. The primary assertion is
[~,e] = log2(x)
With two output arguments, log2 returns the mantissa and exponent of an IEEE-754 floating level quantity. The mantissa isn’t wanted right here.
The second key assertion
e = ceil(e/4)
makes e divisible by 4. This turns e into the suitable hexadecimal exponent in order that the third assertion
f = x.*16.^(-e)
can produce the hexadecimal mantissa.
ieee2ibm
perform z = ieee2ibm(x)
Convert IEEE-754 to IBM System 360 hexadecimal.
z = ieee2ibm(x)
Enter x, actual column vector.
Output z, size(x)-by-16 char.
Instance: ieee2ibm(-118.625) = 'C276A00000000000'.
s = signal(x); % -1, 0, or 1
x = abs(x);
x(x < 16^(-65)) = 0; % Underflow
x(x >= 16^63) = (1-eps/2)*16^63; % Overflow
[~,e] = log2(x); % base 2 exponent
e = ceil(e/4) % base 16 exponent
f = x.*16.^(-e); % base 16 mantissa
E = uint64((e+64)*2^56); % Assemb1e output
F = uint64(f*2^56);
S = uint64((1-s)*2^62); % 1 or 0
z = dec2hex(S + E + F); % z = 'ZZFFFFFFFFFFFFFF'
finish
ibm2ieee
perform x = ibm2ieee(z)
Convert IBM System 360 hexadecimal to IEEE-754.
x = ibm2ieee(z)
Enter z, n-by-16 char.
Output x, n-by-1 double.
Instance: ibm2ieee('C276A00000000000') = -118.625.
E = hex2dec(z(:,1:2)); % Disassemble enter
F1 = hex2dec(z(:,3:8)); % < 16^6
F2 = hex2dec(z(:,9:finish)); % < 16^8
s = signal(128-E); % -1 or 1
e = E-(s>0)*64-(s<0)*192; % base 16 exponent
f = F1/16^6 + F2/16^14; % base 16 mantissa
x = s.*f.*16.^e;
finish
Examples
Underflow. Something < 16^(-65) is simply too small and is flushed to zero. There are not any denormals.
Overflow. Something >= 16^63 is simply too giant. There isn’t a inf or NaN.
* 1.0 4110000000000000 * 0.1 401999999999999A * -pi C13243F6A8885A30 * 5.3976e-79 0010000000000000 * 7.2370e+75 7FFFFFFFFFFFFFF8
Comparability
S/360 hexadecimal has 7 exponent bits, whereas IEEE-754 has 11. Consequently, hexadecimal has a a lot smaller vary, 5.4e-79 to 7.2e+75 versus 2.2e-308 to 1.8e+308.
The bottom-16 normalization implies that hexadecimal successfully has between 53 and 56 mantissa bits. Counting the hidden bit, IEEE-754 additionally has 53. So, the accuracy of the 2 is just about the identical.
Software program
My capabilities ieee2ibm and ieee2ibm described above, modified to deal with each single and double, plus hex_test, which does what its title implies, can be found at Hex_ieee.
Homework: What occurs?
okay = 0;
for ok = 1:10
x = single(ok/10);
okay(ok) = hex_test(x);
finish
okay
Revealed with MATLAB® R2024a
