> '` bjbj oT$OOOPdOP\#jhRhR~R~R~R~R~R~Riiiiiii$khmiT~R~RTTi~R~Ri>\>\>\T0~R~Ri>\Ti>\>\>\~R\R3AOU$>\]i0#j>\_nY_n>\_n>\~RLR6>\S,,Sj~R~R~Rii[d~R~R~R#jTTTTDJOOChapter 13: Handling Floating Point Data
This chapter presents a brief discussion of floating point data and arithmetic. There are a few reasons to cover this topic, but none relate to the expectation that a programmer will actually use this data format in an assembly language program.
The two primary reasons to cover floating point data and arithmetic are simple: 1) So that we can make a plausible claim of a complete coverage of assembler language. 2) So that the student will more fully appreciate some of the complexities (handled by the runtime system of a HLL) of processing floating point data.
There is another reason for the study; this is one that is found in early texts on assembler language. It used to be the case that an understanding of floating point format would allow the programmer to write a HighLevelLanguage program that was considerably more efficient. With modern compilers, this is rarely the case.
The first thing to note in this chapter is the difference between floating point data and fixed point data. It is simple: in the first format the decimal point may be said to float in that it can assume any position in the data. In the fixed point data, the decimal point is fixed at a predefined position. The packed decimal format is a good example of a fixedpoint format.
Consider the two packed decimal numbers defined as follows:N1 DC P1234 Stored as X01234C
N2 DC P567 Stored as X567C
From the viewpoint of assembler language, each of these labels is simply a reference to data in packed decimal format. There is more to the definition than what is stated above. One must view each declaration in terms of a data type, which is a concept taken from a HLL. In particular, the data are defined completely only if the number of decimal places is specified.
So, we must ask if the numbers represented by the labels N1 and N2 are of compatible data type. Again, this cannot be determined from the simple definition. If both values are to be interpreted with the same number of decimal points, the types are compatible.
Suppose that N1 represents the number 12.34.Suppose that N2 represents the number 5.67.The two definitions can be viewed as belonging to a single data type.
Suppose, however that N1 represents the number 1.234, while N2 represents 5.67. Then the definitions belong to what might be called similar, but incompatible, data types. One of the two must be modified by a SRP instruction before they are added, or the results will be silly. One possible redefinition would be as follows:N1A DC P1234 Stored as X01234C for 1.234
N2A DC P5670 Stored as X05670C for 5.670
In the above definition, each constant is defined with three implicit decimal places, and the two can be said to be of a common data type. We must emphasize that the idea of a data type is derived from the theory of highlevel compiled languages and is somewhat foreign to assembler language. However, it is very helpful in understanding fixed point arithmetic.
The basic idea of floating point arithmetic is the explicit storage of a representation of the position of the decimal point in each data item. That way, the CPU can automatically adjust the two to the same basic representation, if that is necessary. As we shall see, this adjustment is required for addition and subtraction, but not multiplication and division.
Consider the above two numbers at labels N1 and N2. Suppose that these are to be interpreted as 1.234 and 56.7 respectively. In floatingpoint notation, these would be represented as 1.234(100 and 5.67(101, respectively.
Addition might proceed by converting these to 1.234(100 and 56.7(100, then adding to get 57.934(100, which might be converted to either 5.7934(101 or 5.793(101. Multiplication will proceed without adjusting either value: 1.234(100 ( 5.67(101 = 6.99678(101, which might be rounded to 7.00(101 , 6.997(101 , or some other value.
As noted before, the floating point format has an advantage, which is simultaneously its disadvantage. The advantage is that the format handles the position of the decimal point explicitly. The disadvantage is that it might round and thereby lose precision.
At this point, the reader should review the material on floating point formats that is found in Chapter 4 (Data Representation) of this textbook. The topics for review should be: 1. Conversion between decimal format and hexadecimal representations, 2. Excess64 representation of integers, 3. normalized and denormalized floating point numbers, and 4. the IBM Mainframe floating point formats.For the readers convenience, the last topic will be summarized below.
The IBM Mainframe FloatingPoint Formats
In this discussion, we shall adopt the bit numbering scheme used in the IBM documentation, with the leftmost (sign) bit being number 0. The IBM Mainframe supports three formats; those representations with more bits can be seen to afford more precision.
Single precision 32 bits numbered 0 through 31, Double precision 64 bits numbered 0 through 63, and Extended precision 128 bits numbered 0 through 127.
As in the IEEE754 standard, each floating point number in this standard is specified by three fields: the sign bit, the exponent, and the fraction. Unlike the IEEE754 standard, the IBM standard allocates the same number of bits for the exponent of each of its formats. The bit numbers for each of the fields are shown below.
FormatSign bitBits for exponentBits for fractionSingle precision01 78 31Double precision01 78 63Extended precision01 78 127Note that each of the three formats uses eight bits to represent the exponent, in what is called the characteristic field, and the sign bit. These two fields together will be represented by two hexadecimal digits in a onebyte field. The size of the fraction field does depend on the format. Single precision 24 bits 6 hexadecimal digits, Double precision 56 bits 14 hexadecimal digits, and Extended precision 120 bits 30 hexadecimal digits.
The Characteristic Field
In IBM terminology, the field used to store the representation of the exponent is called the characteristic. This is a 7bit field, used to store the exponent in excess64 format; if the exponent is E, then the value (E + 64) is stored as an unsigned 7bit number.
Recalling that the range for integers stored in 7bit unsigned format is 0 ( N ( 127, we have 0 ( (E + 64) ( 127, or 64 ( E ( 63.
Range for the Standard
We now consider the range and precision associated with the IBM floating point formats. The reader should remember that the range is identical for all of the three formats; only the precision differs. The range is usually specified as that for positive numbers, from a very small positive number to a large positive number. There is an equivalent range for negative numbers. Recall that 0 is not a positive number, so that it is not included in either range.
Given that the base of the exponent is 16, the range for these IBM formats is impressive. It is from somewhat less than 1664 to a bit less than 1663. Note that 1663 = (24)63 = 2252, and 1664 = (24)64 = 2256 = 1.0 / (2256) and recall that log10(2) = 0.30103. Using this, we compute the maximum number storable at about (100.30103)252 = 1075.86 ( 9(1075. We may approximate the smallest positive number at 1.0 / (36(1075) or about 3.0(1077. In summary, the following real numbers can be represented in this standard: X = 0.0 and 3.0(1077 < X < 9(1075.
One would not expect numbers outside of this range to appear in any realistic calculation.
Precision for the Standard
Unlike the range, which depends weakly on the format, the precision is very dependent on the format used. More specifically, the precision is a direct function of the number of bits used for the fraction. If the fraction uses F bits, the precision is 1 part in 2F.
We can summarize the precision for each format as follows. Single precision F = 24 1 part in 224. Double precision F = 56 1 part in 256. Extended precision F = 120 1 part in 2120.
The first power of 2 is easily computed; we use logarithms to approximate the others. 224 = 16,777,216 256 ( (100.30103)56 = 1016.85 ( 9(1016. 2120 ( (100.30103)120 = 1036.12 ( 1.2(1036.
The argument for precision is quite simple. Consider the single precision format, which is more precise than 1 part in 10,000,000 and less precise than 1 part in 100,000,000. In other words it is better than 1 part in 107, but not as good as 1 in 108; hence we say 7 digits.
Range and Precision
We now summarize the range and precision for the three IBM Mainframe formats.
FormatTypePositive RangePrecisionSingle PrecisionE3.0(1077 < X < 9(10757 digitsDouble PrecisionD3.0(1077 < X < 9(107516 digitsExtended PrecisionL3.0(1077 < X < 9(107536 digitsRepresentation of Floating Point Numbers
As with the case of integers, we shall most commonly use hexadecimal notation to represent the values of floatingpoint numbers stored in the memory. From this point, we shall focus on the two more commonly used formats: Single Precision and Double Precision.
The single precision format uses a 32bit number, represented by 8 hexadecimal digits.The double precision format uses a 64bit number, represented by 16 hexadecimal digits.
Due to the fact that the two formats use the same field length for the characteristic, conversion between the two is quite simple. To convert a single precision value to a double precision value, just add eight hexadecimal zeroes.
Consider the positive number 128.0.As a single precision number, the value is stored as 4280 0000.As a double precision number, the value is stored as 4280 0000 0000 0000.
Conversions from double precision to single precision format will involve some rounding.For example, consider the representation of the positive decimal number 123.45. In a few pages, we shall show that it is represented as follows.
As a double precision number, the value is stored as 427B 7333 3333 3333.As a single precision number, the value is stored as 427B 7333.
The Sign Bit and Characteristic FieldWe now discuss the first two hexadecimal digits in the representation of a floatingpoint number in these two IBM formats. In IBM nomenclature, the bits are allocated as follows. Bit 0 the sign bit Bits 1 7 the sevenbit number storing the characteristic.
Bit Number01234567Hex digit01UseSign bitCharacteristic (Exponent + 64)Consider the four bits that comprise hexadecimal digit 0. The sign bit in the floatingpoint representation is the 8 bit in that hexadecimal digit. This leads to a simple rule.
If the number is not negative, bit 0 is 0, and hex digit 0 is one of 0, 1, 2, 3, 4, 5, 6, or 7.If the number is negative, bit 0 is 1, and hex digit 0 is one of 8, 9, A, B, C, D, E, or F.
Some Single Precision ExamplesWe now examine a number of examples, using the IBM singleprecision floatingpoint format. The reader will note that the methods for conversion from decimal to hexadecimal formats are somewhat informal, and should check previous notes for a more formal method. Note that the first step in each conversion is to represent the magnitude of the number in the required form X(16E, after which we determine the sign and build the first two hex digits.
Example 1: True 0
The number 0.0, called true 0 by IBM, is stored as all zeroes [R_15, page 41].In single precision it would be 0000 0000.In double precision it would be 0000 0000 0000 0000.
Example 2: Positive exponent and positive fraction.
The decimal number is 128.50. The format demands a representation in the form X(16E, with 0.625 ( X < 1.0. As 128 ( X < 256, the number is converted to the form X(162.Note that 128 = (1/2)(162 = (8/16)(162 , and 0.5 = (1/512)(162 = (8/4096)(162.Hence, the value is 128.50 = (8/16 + 0/256 + 8/4096)(162; it is 162(0x0.808.
The exponent value is 2, so the characteristic value is either 66 or 0x42 = 100 0010. The first two hexadecimal digits in the eight digit representation are formed as follows.
FieldSignCharacteristicValue01000010Hex value42The fractional part comprises six hexadecimal digits, the first three of which are 808.The number 128.50 is represented as 4280 8000.
Example 3: Positive exponent and negative fraction.
The decimal number is the negative number 128.50. At this point, we would normally convert the magnitude of the number to hexadecimal representation. This number has the same magnitude as the previous example, so we just copy the answer; it is 162(0x0.808.
We now build the first two hexadecimal digits, noting that the sign bit is 1.
FieldSignCharacteristicValue11000010Hex valueC2The number 128.50 is represented as C280 8000.Note that we could have obtained this value just by adding 8 to the first hex digit.
Example 4: Negative exponent and positive fraction.
The decimal number is 0.375. As a fraction, this is 3/8 = 6/16. Put another way, it is 160(0.375 = 160((6/16). This is in the required format X(16E, with 0.625 ( X < 1.0.
The exponent value is 0, so the characteristic value is either 64 or 0x40 = 100 0000. The first two hexadecimal digits in the eight digit representation are formed as follows.
FieldSignCharacteristicValue01000000Hex value40The fractional part comprises six hexadecimal digits, the first of which is a 6.The number 0.375 is represented in single precision as 4060 0000.The number 0.375 is represented in double precision as 4060 0000 0000 0000.
Example 5: A Full ConversionThe number to be converted is 123.45. As we have hinted, this is a nonterminator.
Convert the integer part.123 / 16 = 7 with remainder 11 this is hexadecimal digit B. 7 / 16 = 0 with remainder 7 this is hexadecimal digit 7.Reading bottom to top, the integer part converts as 0x7B.
Convert the fractional part.0.45 ( 16 = 7.20 Extract the 7,0.20 ( 16 = 3.20 Extract the 3,0.20 ( 16 = 3.20 Extract the 3,0.20 ( 16 = 3.20 Extract the 3, and so on.
In the standard format, this number is 162(0x0.7B33333333...
The exponent value is 2, so the characteristic value is either 66 or 0x42 = 100 0010. The first two hexadecimal digits in the eight digit representation are formed as follows.
FieldSignCharacteristicValue01000010Hex value42The number 123.45 is represented in single precision as 427B 3333.The number 0.375 is represented in double precision as 427B 3333 3333 3333.
Example 5: One in ReverseWe are given the single precision representation of the number. It is 4110 0000.What is the value of the number stored? We begin by examination of the first two hex digits.
FieldSignCharacteristicValue01000001Hex value41The sign bit is 0, so the number is positive. The characteristic is 0x41, so the exponent is1 and the value may be represented by X(161. The fraction field is 100 000, so the value is161((1/16) = 1.0.
Example 6: Another in ReverseWe are given the single precision representation of the number. It is BEC8 0000.What is the value of the number stored? We begin by examination of the first two hex digits.
FieldSignCharacteristicValue10111110Hex valueBEThe characteristic has value 0x3E or decimal 3(16 + 14 = 62. The exponent has value62 64 = 2. The number is then 16-2(0x0.C8 = 16-2((12/16 + 8/256), which can be converted to decimal in any number of ways. I prefer the following conversion.16-2((12/16 + 8/256) = 16-2((3/4 + 1/32) = 16-2((24/32 + 1/32) = 16-2((25/32) = 25 / (32(256) = 25 / 8192 ( 3.0517578(103.The answer is approximately the negative number 3.0517578(103.
Why Excess64 Notation for the Exponent?
We have introduced two methods to be used for storing signed integers: twoscomplement notation and excess64 notation. One might well ask why twos-complement notation is not used to store the exponent in the characteristic field.
The answer for integer notation is simple. Consider some of examples.
128.50 is represented as 4280 8000. Viewed as a 32bit integer, this is positive.
128.50 is represented as C280 8000. Viewed as a 32bit integer, this is negative. 1.00 is represented as 4110 0000. Viewed as a 32bit integer, this is positive.3.05(103 is represented as BEC8 0000. Viewed as a 32bit integer, this is negative
It turns out that the excess64 notation allows the use of the integer compare unit to compare floating point numbers. Consider two floating point numbers X and Y. Pretend that they are integers and compare their bit patterns as integer bit patterns. It viewed as an integer, X is less than Y, then the floating point number X is less than the floating point Y. Note that we are not converting the numbers to integer form, just looking at the bit patterns and pretending that they are integers. For example, the above examples would yield the following order.
4280 8000 for 128.50. This is the largest.4110 0000 for 1.00.BEC8 0000 for 3.05(103.C280 8000 for 128.50. This is the most smallest (most negative).
Examples of FloatingPoint Declaratives
Floating point storage and constants are defined with the standard DS and DC declaratives. There are three possible formats: E (Single Precision), D (Double Precision) and L (Extended Precision). Standard programs use the E (Single Precision) format, with occasional use of the D (Double Precision) format. The L format is probably unusual.
Here are some examples of floatingpoint declaratives.
FL1 DS E This defines a 4byte storage area, aligned
on a fullword boundary. Presumably, it will store Single Precision Data.
DL1 DS D An 8-byte storage area, aligned on a double word boundary. It could store data in Double Precision format.
FL2 DS E12.34 Define a single precision value.
FL3 DS E-12.34 The negative of the above value.
DL2 DS D0.0 The constant 0.0, in double precision.
The reader may recall that we have used statements, such as the DL1 declarative, to reserve an 8byte storage area aligned on a doubleword boundary, for use in the CVB and CVD instructions associated with packed decimal arithmetic. This emphasizes the fact that the declaratives do not really determine a data type, but just set aside storage. In assembler language, it is the instructions that determine the data type.
Before proceeding, we must give a disclaimer. There are a few features of floatingpoint arithmetic, such as the exponent modifier and scale modifier, that will not be covered in this discussion. This discussion will also be limited to normalized floatingpoint numbers and totally ignore the unnormalized instructions which handle data not in normalized format.
The FloatingPoint Registers
In addition to the sixteen generalpurpose registers (used for binary integer arithmetic), the S/360 architecture provides four registers dedicated for floatingpoint arithmetic. These registers are numbered 0, 2, 4, and 6(*). Each is a 64bit register. It is possible that the use of even numbers to denote these registers is to emphasize that they are not 32bit registers.
The use of the registers by the floatingpoint operations depends on the precision. Single precision formats use the leftmost 32 bits of a floatingpoint register. Double precision formats use all 64 bits of the register. Extended precision formats use two adjacent registers for a 128 bit number.
In order to understand why it is the leftmost 32 bits of the register that are used for the 32bit single precision floatingpoint format, we must consider what is involved in extending the single precision format to a double precision format.
Consider the singleprecision constant 123.45, which would be represented by the 32bit (8 hexadecimal digit) constant 427B 3333. Were this to be extended to double precision, it would be stored as the 64bit constant 427B 3333 0000 0000. In other words, each floating point register stores a value as if it were a doubleprecision value; the singleprecision values being stored as values with limited precision.
As we saw above, a conversion of 123.45 directly to the doubleprecision floatingpoint format would yield the value 427B 3333 3333 3333, rather than the truncated value 427B 3333 0000 0000 seen above. Put another way, singleprecision values stored as double precision are not as precise as true doubleprecision constants.
To make this point completely obvious, suppose that a 64bit floatingpoint register contains the following value, expressed as 16 hexadecimal digits.
Byte01234567Value427B333333333333An E format (Single Precision) floatingpoint reference to this register would access only the leftmost four bytes and use the value 427B 3333. A D format (Double Precision) floatingpoint reference would access all eight bytes and use the value 427B 3333 3333 3333. Each reference should correspond to the decimal value 123.45, just with different precision.
As a side note, some early versions of FORTRAN might print the above number at something like 123.449999, due to the fact that 123.45 cannot be represented exactly as a floatingpoint number. The FORMAT statement provided by the FORTRAN runtime system was modified to round this value to 123.45.
* Modern System/z architecture supports 16 floatingpoint registers, numbered 0 15. The additional registers (1, 3, 5, and 7 15) are useable if the AFPR option has been selected in the ACONTROL instruction for the code. [R-17, page 100]
The FloatingPoint Instructions
The floatingpoint instruction set is less extensive than the binary integer instruction set, but bears some similarities. The instructions are in two formats: RR (Register to Register) and RX (Register and Indexed Storage). Obviously the register reference in these instructions are the floatingpoint registers. The mnemonics for the instructions are structured into three parts: a one or two character code for the operation, followed by a character indicating the precision, then either a blank for type RX or an R for type RR.
The Load Instructions
The load instructions load a 64bit floating point register from either storage or another floatingpoint register. The valid register numbers are 0, 2, 4, or 6.
LE R1,D2(X2,B2) Load R1 single precision from memory Operand 2 is an aligned fullword; its address is a multiple of 4.
LD R1,D2(X2,B2) Load R1 double precision from memory Operand 2 is an aligned double word; its address is a multiple of 8.
LER R1,R2 Load the leftmost 32 bits of R1 from the leftmost 32 bits of R2.
LDR R1,R2 Load the 64-bit register R1 from the 64-bit register R2.
Neither LE or LER change the rightmost 32 bits of the target floatingpoint register.
The opcodes for the two type RR instructions are as follows: LER X38 LDR X28
The object code format for these type RR instructions follows the standard. Each is a twobyte instruction of the form OP R1,R2.
TypeBytesOperandsRR2R1,R2OPR1 R2The first byte contains the 8bit instruction code.
The second byte contains two 4bit fields, each of which encodes a register number.
This instruction format is used to process data between registers.
The opcodes for the two type RX instructions are as follows: LE X78 LD X68
Each is a fourbyte instruction of the form OP R1,D2(X2,B2).
TypeBytesOperands1234RX4R1,D2(X2,B2)OPR1 X2B2 D2D2D2The first byte contains the 8bit instruction code. The second byte contains two 4bit fields, each of which encodes a register number. The third and fourth bytes contain an address in the standard base/displacement with index register format. The load instructions do not set any condition code.
The Store Instructions
There are two store instructions for storing either the leftmost 32 bits or all 64 bits of the 64 bit floatingpoint registers. Again, the valid register numbers are 0, 2, 4, or 6.
STE R1,D2(X2,B2) Store the 32 leftmost bits of register R1 as a single precision result into the aligned fullword address.
STD R1,D2(X2,B2) Store the 64 bits of register R1 as a double precision result into the aligned double word address.
The opcodes for these two instructions are as follows: STE X70 STD X60.
Each is a fourbyte instruction of the form OP R1,D2(X2,B2).
TypeBytesOperands1234RX4R1,D2(X2,B2)OPR1 X2B2 D2D2D2The first byte contains the 8bit instruction code. The second byte contains two 4bit fields, each of which encodes a register number. The third and fourth bytes contain an address in the standard base/displacement with index register format.
The rules for forming the address of operand 2 in each of the above instructions follow the standard for type RX instructions. Again, the only new feature is that the address of the operand must be properly aligned. In practice that means using the proper declarative for specifying the storage.
Single precision Use DS E or DC E, to insure that the address is a multiple of 4.
Double precision Use DS D or DC D, to insure that the address is a multiple of 8.
Sample Code
LOAD1 LE 0,FL1 LOAD FP REG 0 FROM ADDRESS FL1
LOAD2 LD 2,FL2 LOAD DOUBLE PRECISION
LOAD3 LER 4,0 COPY SINGLE PRECISION INTO FP REG 4
LOAD4 LDR 6,2 COPY DOUBLE PRECISION INTO FP REG 6
STORE1 STE 6,FL3 STORE THE SINGLE PRECISION INTO FL3
STORE2 STD 6,FL4 STORE DOUBLE PRECISION INTO FL4
FL1 DC E123.45 A SINGLE PRECISION FLOATING POINT
CONSTANT. ADDRESS IS A MULTIPLE OF 4.
FL2 DC D45678.90 A DOUBLE PRECISION FLOATING POINT CONSTANT. ADDRESS IS A MULTIPLE OF 8.
FL3 DS E JUST RESERVE AN ALIGNED FULLWORDFL4 DS D RESERVE AN ALIGNED DOUBLE WORD.
Note that the contents of register 6 are first stored as a single precision result, thenas a double precision result.
Addition and Subtraction
There are four distinct addition instructions and four distinct subtraction instructions for normalized floatingpoint numbers. These instructions are as follows:
MnemonicOperationOpcodeOperand FormatAEAdd single precision7AR1,D2(X2,B2)ADAdd double precision6AR1,D2(X2,B2)AERAdd register single precision3AR1,R2ADRAdd register double precision2AR1,R2SESubtract single precision7BR1,D2(X2,B2)SDSubtract double precision6BR1,D2(X2,B2)SERSubtract register single precision3BR1,R2SDRSubtract register double precision2BR1,R2Subtraction functions by changing the sign of the second operand and then performing an addition. The first step in each is ensuring that the characteristics of both operands are equal. If unequal, the field with the smaller characteristic is adjusted by shifting the fraction to the right and incrementing the characteristic by 1 until the characteristics are equal.
Each of these operations sets the proper condition code for conditional branching.
Recall that the standard floating point format is as follows:
Leftmost 8 bitsOther bitsSign bit7bit characteristicThe fractionHere is an example of adjusting the characteristic.
Characteristic Fraction 41 29000 = 41 29000 40 12000 = 41 01200 41 2A200
Suppose that the fraction overflows. If that happens, the fraction is shifted right by one hexadecimal digit and the characteristic is incremented by 1. This last operation is called normalization, in that it returns the result to the expected normal form.
Characteristic Fraction 41 940000 41 760000 41 10A0000 which becomes 42 010A000.
Normalized addition and subtraction perform postnormalization; that is, they normalize the result after the operation. This is seen in the example above. Precision is maintained by use of a guard digit, which saves the last digit shifted during normalization prior to addition or subtraction. This digit may be restored during postnormalization. Here is an example.
Characteristic Fraction 42 0B2584 = 42 0B2584 40 114256 = 42 001142(5) 5 is the guard digit. 42 0B36C6(5)Normalize the result 41 B36C65.
Here are some examples of the operation, which appear exactly as expected.
* SINGLE PRECISION FLOATING POINT ADDITION
*
ADDSNG LE 2,FL1 LOAD THE REGISTER
AE 2,FL2 ADD SINGLE PRECISION
LE 4,FL3 LOAD ANOTHER REGISTER
AER 4,2 REGISTER 4 IS CHANGED
*
* SINGLE PRECISION FLOATING POINT SUBTRACTION
*
SUBSNG LE 2,FL1 LOAD THE REGISTER
SE 2,FL2 SUBTRACT FROM THE VALUE IN REG 2
LE 4,FL3 LOAD ANOTHER REGISTER
SER 4,2 SUBTRACT REG 2 FROM REG 4,
CHANGING THE VALUE IN REGISTER 4
*
* DOUBLE PRECISION FLOATING POINT ADDITION
*
ADDDBL LD 2,FL1 LOAD THE REGISTER
AD 2,FL2 ADD DOUBLE PRECISION
LD 4,FL3 LOAD ANOTHER REGISTER
ADR 4,2 REGISTER 4 IS CHANGED
*
* DOUBLE PRECISION FLOATING POINT SUBTRACTION
*
SUBBDL LD 2,FL1 LOAD THE REGISTER
SD 2,FL2 SUBTRACT FROM THE VALUE
LD 4,FL3 LOAD ANOTHER REGISTER
SDR 4,2 REGISTER 4 IS CHANGED
*
* A FEW MIXED OPERATIONS
*
MIXED LD 2,FL1 DOUBLE PRECISION LOAD
AE 2,FL2 SINGLE PRECISION ADDITION
SE 2,FL3 SINGLE PRECISION SUBTRACTION
STD 2,FL1 STORE AS DOUBLE PRECISION, THOUGH THE
RESULT IS NOT QUITE THAT PRECISE
*
FL1 DC D 123.4
FL2 DC D 10.0
FL3 DC D 150000.0
Consider the mixed precision operations in which both single precision and double precision floating point numbers are used. The result is certainly less precise than a true double precision result, though possibly a bit more precise than a single precision one. This last claim of precision greater than single would be difficult to justify.
Multiplication
There are four distinct floatingpoint multiplication operations.
MnemonicActionOpcodeOperandsMEMultiply single precision7CR1,D2(X2,B2)MDMultiply double precision6CR1,D2(X2,B2)MERMultiply single (register)3CR1,R2MDRMultiply double (register)2CR1,R2In each, the first operand specifies a register that stores the multiplicand and,after the multiplication, stores the product.
The operation normalizes the product, which in all cases is a doubleprecision result.
Division
There are four distinct floatingpoint division operations.
MnemonicActionOpcodeOperandsDEDivide single precision7DR1,D2(X2,B2)DDDivide double precision6DR1,D2(X2,B2)DERDivide single (register)3DR1,R2DDRDivide double (register)2DR1,R2In each, the first operand specifies a register that stores the dividend and,after the division, stores the quotient. There is no remainder.
The operation normalizes the quotient, which in all cases is a doubleprecision result.
A divisor containing a zero fraction causes a program interrupt. Recall that the two parts of any number in IBM floating point format are the characteristic and the fraction. The characteristic is held in the leftmost byte of the format and represents the sign and exponent. The fraction is held in the rest of the format: for single precision this is the 24 rightmost bits, and for double precision this is the 56 rightmost bits.
Comparison
There are four distinct floatingpoint division comparison operations.
MnemonicActionOpcodeOperandsCECompare single precision79R1,D2(X2,B2)CDCompare double precision69R1,D2(X2,B2)CERCompare single (register)39R1,R2CDRCompare double (register)29R1,R2In each, the comparison sets the condition codes as would be expected for comparisons in the other formats. Each operation proceeds as a modified subtraction. The characteristic fields of the two operands are checked, and the smaller exponent is incremented while right shifting its fraction (denormalizing the number, but preserving its value) before the comparison.
If both operands have fractions that are zero (all bits in the field are 0), the result isdeclared to be equal without consideration of either the exponent or the sign.
The single precision operations compare only the leftmost 32 bits in each value.
Conversions To and From Floating Point
We now briefly discuss conversion of data between the three main forms that we have discussed at this time: twoscomplement integer, packed decimal, and floating point. We begin by considerations related to conversion to and from integer data.
Recall that all floating point formats store data in the form 16E(F, where F is a fraction not less than 1/16 = 0.625 and less than 1.0. Of particular interest here are the values 161 = 16, and 168 = (24)8 = 232 = 4,294,967,296.
Recall that a 32bit twoscomplement format can represent integers in a specific range with the most negative value being 2,147,483,648 and the most positive being 2,147,483,647. In terms of powers of 2, this range is from (231) to (231 1). We see that 231 = 168(1/2.
Consider nonzero integers. The range consistent with the fullword format is as follows.The smallest magnitude is 1 = 161((1/16); the exponent is 1, stored as 65 = X41.The largest magnitude is 231 = 168(1/2; the exponent is 8, stored as 72 = X48.
Immediately, we see that positive floating point numbers with characteristic fields at least X41 but not greater than X48 can be converted to integer form. If the characteristic field is less than X41, the floatingpoint value will be come an integer 0. If the characteristic field is greater than X48, the value is too large to be represented.
The primary difficulty with conversions between packed decimal format and floatingpoint format is the fact that the position of the decimal point in packed format is not specified. This difficulty presents itself in different forms, depending on the exact operation.
In translation from packed decimal to floatingpoint, the position of the decimal point must be explicitly specified in order to correctly set the exponent.
In translation from floatingpoint to packed decimal, the computations can be done almost exactly, but there is no place to store a value representing the position of the decimal point.
We shall explore these conversions again after we have developed a few more tools that can be used in scanning an array of digits or an array of bytes.
Input and Output of Floating Point Values
At this point in the chapter, the reader should be aware of a glaring omission. There has been no discussion of conversion from EBCDIC format to any of the floatingpoint formats or conversions from those formats back to EBCDIC. In other words, there has been no mention of methods to write assembly language programs either to read floating point data or to print those data in some readable format.
The plain fact is that floatingpoint I/O is not mentioned in any standard source, either the textbooks [R_02, R_05, R_07, or R_18] or in any of the IBM manuals for the S/370 and successor systems [R_15, R_16, R_17, R_19, R_20, R_21, R_22, or R_23]. A request to IBM for any information yielded only a copy of the z/Series Principles of Operation [R_16].
It is likely the case that nobody writes complete floatingpoint oriented programs in IBM Assembler Language and has not for quite a few years. If your author finds any additional information, it will be shared in the next revision of this textbook.
Page PAGE 268 Chapter 13 Last revised August 2, 2009 Copyright 2009 by Edward L. Bosworth, Ph.D.
S/370 Assembler Floating Point Data
()&
'
c
e
n
$%^`eg8:egtu··ۥwwwi^iZh5vhj=5OJQJ^Jh{hj=5OJQJ^Jhj=hj=5OJQJ^Jhj=hj=h5OJQJ^Jhh5OJQJ^Jhh{h5OJQJ^Jh5OJQJ^Jh{5OJQJ^Jh{h{5OJQJ^Jh{h|QhNUhNUh+5CJaJhNUhNU5CJaJ#) d
'
%+CuP/x|T}gd!t
hxgdj=
hgdj=
hxgd
hgd{
hxgdNU $ha$gdNUy{./bcefoprs!",-/0PQST\]_`|4Lu|T}_Ҿh!thNjh!t>*hxh=,h1Fh hVH*hVhVH* jhVhVhVhj=5OJQJ^Jhj=F}{_fo$
h$Ifa$gd'
h$Ifgd'
hxgd!t
h xgd!tgd1F[N>>>$
h$Ifa$gd'
h$Ifgd'kd$$Ifl\(8$
t0644
layt'[N>>>$
h$Ifa$gd'
h$Ifgd'kd$$Ifl\(8$
t0644
layt'[N>>>$
h$Ifa$gd'
h$Ifgd'kd"$$Ifl\(8$
t0644
layt' i![ND88
h xgd!t
h gd!t
hxxgd1Fkd$$Ifl\(8$
t0644
layt'_s :<RTno7 G 1!2!5!6!F!G!Q!R!_!`!c!d!i!!!##########$$$$$$$$$$ $#$$$/$1$2$G$I$$$$$$$$ººººººººººººººh>N$h{H* h{H*h>N$h{H*h{hh{>* h{>* jh!thQh!t5hQh!t>* h!t>*h1Fh!th
h!t5Di!!O#%%%''}())))***$$Ifa$gd' $Ifgd'
hxgdFxgdFgdFxgdsxgd{
hgd{$$$$$$$$$$% %%%l%m%o%r%z%{%}%%%%%%&'a'c'''''((((*(+(,(0(7(8(:(?(D(F(G(I(J(L(N(R(U(V(W([(b(c(f(k(p(q(r(v(w(y(ӼӴӯӯӼӨӯӼӴӯӯӼӨ jhF hFH*h>N$hFH* jhFhjhFH*h5hFH*hFh5hF>*h>N$h{h5h{H* jh{h{ jh{By({([)\)x)y))))))*0*1*3*6*>*?*A*C*d*e*g*j*r*s*u*w************,,--.,.N/a/////22h9hF>*hN.hF>*hFOJQJ^Jhu]hFOJQJ^JhhFhhF>* hF>*h5hf.cH* jhf.chf.c hf.c5h8@hf.c5h8@hF>*h
,4hFH*hF hFH*4**+*-*D*M*WNBBB$$Ifa$gd' $Ifgd'kdD$$IfTl\prJR
t0644
laytf.cTM*N*_*a*x**WNBBB$$Ifa$gd' $Ifgd'kd$$IfTl\prJR
t0644
laytf.cT******WNBBB$$Ifa$gd' $Ifgd'kdn$$IfTl\prJR
t0644
laytf.cT***+,-../WPIII>I
dxgdFxgdFxgdFkd$$IfTl\prJR
t0644
laytf.cT//00000000000000Ffq$$Ifa$gd' $Ifgd'xgdF
dxgdF0001&1jaUU$$Ifa$gd' $Ifgd'kd}$$IfTlFT$
t0644
layt'T&1'112y44<5q5jaZZUJEgdF
xgdBHgd
xgdFxxgdFkd$$IfTlF
T8
t0644
layt'T2234-4.40414y4444445'5:5;5<5=5E5F5q555555555666606163646=6>6@6A6U6V6X6Y6d6e6g6h66666666%8ʼʼҷ hFH* jhF hBH5h9hF5 hF5hBHhBH5OJQJ^JhBHhV4h
h
h
5h9hFH* jhFh5hF5hFh9hF:q56h7n7s77777Nkd{$$IfTlF
T8
t0644
layt'T$$Ifa$gd' $Ifgd'xgdF777777777777 $Ifgd'Ff
$$Ifa$gd'7708d8h9999ja\UUL@$$Ifa$gd' $Ifgd'xgdFgdFxxgdFkd$$IfTlFT$
t0644
layt'T%8.8088898Q8Y8d8]9^9_9:$:{::::::
;;;;;;A;B;D;E;R;S;<<=,=.=/=7=8=K=======>>>>>۰팣hhFOJQJ^JhFOJQJ^Jh=hFOJQJ^JhAhFOJQJ^JhAhF5 jhFh9hFH*hhFH* jhF hFH* hF5 hBH5h9hF5hFhBHhF5OJQJ^J29999999999^U $Ifgd'kd$$IfTlF
T8
t0644
layt'T$$Ifa$gd' 99999999{:PGxxgdFkd2$$IfTlFT$
t0644
layt'T $Ifgd'Ff&$$Ifa$gd'{::];<<<(<)</<Ikd$$IfTlF
T8
t0644
layt'T$$Ifa$gd' $Ifgd'xgdFgdF/<1<3<5<7<9<;<=<?<@<J<L<N< $Ifgd'FfA$$Ifa$gd'N<O<.==n>?T?@@jaaa\UUL $Ifgd'xgdFgdFxxgdFkdM$$IfTlFT$
t0644
layt'T>>>>>>>>>>>>>>>??@?A?~@@@@@@@8A9A*h!(thFh|L[hF5H* jh|L[hF5h|L[hF5hGfhFH* jhFhF jhF hFH*-xEEFFF'G%H&H[JJ"K{LLLaMN;NoNNPPQ
hxgdFU4
hgd{r-
hxgdNU
hgd{r-xgdk`xgdF
hxgdFgdFxgdFGGGGGGG$H%HBHEH[JdJhJjJoJJJJJJJJJJJJJJJJJ!K"KLLLùѲѫѝѹѝѹѝѝѐш|nch{r-5OJQJ^Jh{r-h{r-5OJQJ^Jh{r-h{r-h5h{r-h{r-5h7hFOJQJ^JhhF5OJQJ^Jh!hFh|L[hFhFOJQJ^JhBHhF5OJQJ^JhFh!hFH*OJQJ^Jh!hFOJQJ^J jh!hFOJQJ^J$LLLLM`MaMNNNNNOQOVOYOOPPPQPQQQRRUSVSUUTVgVVWWWWWWWWW+YY~s~s~oh<)BhF5OJQJ^Jh".hF5OJQJ^JhFh".h".5OJQJ^JhAh".h".h(5h|Mh(hi]h{r-hFU4hFU45OJQJ^JhFU45OJQJ^JhFU4h{r-hjw5OJQJ^Jh{r-5OJQJ^Jhjw5OJQJ^J(QQVSTxUW_XXXXXYYYY YYYYYYYYFf!$
hx$Ifa$gdF
hx$IfgdNU
hxgdNU
hgd".Y!Y$Y'Y*Y+YZ[\\^__K``[aabfb
hgd4p
hxgdNU
hgd^
hxgdA
hxxgd<)BFf\$$
hx$Ifa$gdFYY"Z,Z0Z1Z5Z6ZZZ[\\\\^^^^____J`K`aaaaabUbVbZb¾ҨrrncUhi]hi]5OJQJ^Jhi]5OJQJ^Jhi]h`u9h`u95OJQJ^Jh4p5OJQJ^Jhj5OJQJ^Jhjh4p5OJQJ^Jh`u9h4ph4p>*h4ph4p5OJQJ^Jh4ph^hF5h^h^5h^hAhFh{Ch<)B5OJQJ^Jh<)Bh".h<)B5OJQJ^J!Zb[b\b`babebfbbbbbbbbbccccc!d"d&d'd(d+d,d0d1d5d]dldydddddddddddddddd:eeeeккׯׯhjhjh`u9h9Oh
H*h
h
5OJQJ^Jh9Oh
hjt5OJQJ^Jh9OhjtH*hjthjt5OJQJ^Jh9Ohjthjthhi]hi]5OJQJ^Jhi]5OJQJ^Jh
hi]3fbbbbbbb$
h$ $Ifa$gdd
hxgdjtbcccccD1111$
h$ $Ifa$gddkdc&$$IfTlrxd
t0644
laytdTcccIc1#
h$ xgdjtkd'$$IfTlrxd
t0644
laytdT$
h$ $Ifa$gddIccc1dndsdydddddd$
h$ $Ifa$gdd
h$ xgd
hxgdjt
h$ xgdjt
h$ gdjtddkd'$$IfTl֞l<88
t0644
laytdTdddddddd$
h$ $Ifa$gddddkd($$IfTl֞l<88
t0644
laytdTdeefSgg@h}hhhhhhhh$
h$ $Ifa$gdd
h$ xgd[
h
xgd[
hxgdNU
hgd[
h$ xgd`u9eeeeffg/h0h4h9h:h>h@hDhlh{hhhhhhhhhhhhhhhhhIiiijjjjk3k4kIkMkQkUkkǹǹҲҲҲҕh"ihVE5OJQJ^JhVEh]h]h]h9Oh[H*h
h[5OJQJ^Jh9Oh[h[h[5OJQJ^Jh[5OJQJ^Jh[hj5OJQJ^Jhjhj5OJQJ^Jhjhj>* h[>*hj/hhkdK)$$IfTl֞l<88
t0644
laytdThhhhhhhh$
h$ $Ifa$gddhhkd*$$IfTl֞l<88
t0644
laytdThij4kkkkk3lolllm\mmFnnn{oo$
h$Ifa$gde
hgd
hgd.
hxgd]
hgd]
hxgdNU
h$ xxgd[kkkkkkkkkllGlKllllllEnFnnnnzo{o
q~rrrsssssssstк~scs~_h\h$qh$q5>*OJQJ^Jh$q5OJQJ^Jh$qh$q5OJQJ^Jh$qh
h: Uheh h >*h h]h]h.5OJQJ^Jh.5OJQJ^Jh-0|5OJQJ^Jh]5OJQJ^Jh]h]5OJQJ^Jh]hj>*h]h]>*h]hVE%ooooooo:kd*$$Ifl\|48
t0644
layte$
h$Ifa$gde
h$Ifgdeooooooo:kdn+$$Ifl\|48
t0644
layte
h$Ifgde$
h$Ifa$gdeoooopp"pL::$
h$Ifa$gdekd+$$Ifl\|48
t0644
layte
h$Ifgde"p#p'pEpHpNp[I:I:
h$Ifgde$
h$Ifa$gdekd,$$Ifl\|48
t0644
layteNpOpRplpop|p[I:I:
h$Ifgde$
h$Ifa$gdekd!-$$Ifl\|48
t0644
layte|p}ppppp[I:I:
h$Ifgde$
h$Ifa$gdekd-$$Ifl\|48
t0644
laytepppppp[I:I:
h$Ifgde$
h$Ifa$gdekdC.$$Ifl\|48
t0644
laytepppqqq[I:I:
h$Ifgde$
h$Ifa$gdekd.$$Ifl\|48
t0644
layteq
qrrs s[MMA/$
h$Ifa$gd$q
hxgdNU
hxxgd: Ukde/$$Ifl\|48
t0644
layte s+s,s5sJsWsk\\\
h$Ifgd$qkd/$$IfTl0\
T
t0644
layt$qT$
h$Ifa$gd$qWsXssst3uvj\PD8D
xgd\
hxgdNU
pxgd$q
hxxgd$qkd_0$$IfTlF\
XpT
t0644
layt$qTtttuu&u2u3uvvvvvvvvvvw8w9w:wwwww{||4~5~6~ƻƻƌ}r}gYUUhihk
h5OJQJ^Jh5OJQJ^Jh5OJQJ^Jhk
5OJQJ^Jhh
h)vQh)vQ5OJQJ^Jh)vQ5>*OJQJ^Jh$qh)vQ5>*OJQJ^Jh)vQ5OJQJ^Jh$qh)vQ5OJQJ^Jh)vQh\h\h\5OJQJ^Jh\h\5OJQJ^Jh\h$qv9wwwwwx;xhxjxxxxy/yayyyyyy$zQz~zzzz
hgdk
hxgdNU
pgd
zz{<{i{k{{{{{|\||||||5~E~~~$
h$Ifa$gdi
hgdi
hxgdNU
hxgdi
hgdk
6~E~V,-56 у҃܃݃`a\01>?DEFGKM^_DFMOdfklmh6i jh/y3h/y3h/y3H*h/y3 jheqheqheqH*heqheqh*5 hd5h
h*hih*5 h*5h3hihKs5 hKs5hKsh=Hhihihi52~~~~~~~:kd0$$Ifl\|xl
8
t0644
layti$
h$Ifa$gdi
h$Ifgdi~~~~~~~:kdo1$$Ifl\|xl
8
t0644
layti
h$Ifgdi$
h$Ifa$gdi~#&,L::$
h$Ifa$gdikd2$$Ifl\|xl
8
t0644
layti
h$Ifgdi,-1LOU[I:I:
h$Ifgdi$
h$Ifa$gdikd2$$Ifl\|xl
8
t0644
laytiUV-6[MA5
hgdKs
hxgdNU
hxxgd=Hkd"3$$Ifl\|xl
8
t0644
layti6r{
h$Ifgd-[$
h$Ifa$gd-[
hxgdKs[I:I:
h$Ifgd-[$
h$Ifa$gd-[kd3$$Ifl\|xl
8
t0644
layt-[ڀ݀[I:I:
h$Ifgd-[$
h$Ifa$gd-[kdD4$$Ifl\|xl
8
t0644
layt-[[I:I:
h$Ifgd-[$
h$Ifa$gd-[kd4$$Ifl\|xl
8
t0644
layt-[/28[I:I:
h$Ifgd-[$
h$Ifa$gd-[kdf5$$Ifl\|xl
8
t0644
layt-[89ȁ ҃[MA5
hxgdNU
hxgdKs
hxxgdKskd5$$Ifl\|xl
8
t0644
layt-[҃݃$-4;D
h$Ifgd-[$
h$Ifa$gd-[
hxgd*
hgd*DEHadq[I:I:
h$Ifgd-[$
h$Ifa$gd-[kd6$$Ifl\|xl
8
t0644
layt-[qru[I:I:
h$Ifgd-[$
h$Ifa$gd-[kd7$$Ifl\|xl
8
t0644
layt-[Ƅ[I:I:
h$Ifgd-[$
h$Ifa$gd-[kd7$$Ifl\|xl
8
t0644
layt-[ƄǄ˄[I:I:
h$Ifgd-[$
h$Ifa$gd-[kd;8$$Ifl\|xl
8
t0644
layt-[a\y[MMMC7
hxgdNU
hgdeq
hxxgd*kd8$$Ifl\|xl
8
t0644
layt-[y_rpӌ}7Ϗ_`
hgd"Q
hxgdNU9;@ABilmnop͋ҋ:?ҌӌߍϏڠ}}}}yojh+0JUh+hjhUhjh"Qh"Qh"Qh"Q5heshdh6i5OJQJ^Jh/y3h6i5OJQJ^Jh6ihb5OJQJ^Jh/y3hb5OJQJ^Jhb jh/y3h/y3h/y3H*h/y3h/y3h/y35OJQJ^J+!)^hjh"Qhh+
hr0Jh"Q0JmHnHujh+0JU
h+0J
901hP:p/ =!"#$%21h:pNU/ =!"#$%$$If!vh5(585$ 5#v(#v8#v$ #v:Vl
t65(585$ 5yt'$$If!vh5(585$ 5#v(#v8#v$ #v:Vl
t65(585$ 5yt'$$If!vh5(585$ 5#v(#v8#v$ #v:Vl
t65(585$ 5yt'$$If!vh5(585$ 5#v(#v8#v$ #v:Vl
t65(585$ 5yt'$$If!vh555 5#v#v#v #v:Vl
t6555 5ytf.cT$$If!vh555 5#v#v#v #v:Vl
t6555 5ytf.cT$$If!vh555 5#v#v#v #v:Vl
t6555 5ytf.cT$$If!vh555 5#v#v#v #v:Vl
t6555 5ytf.cT$$If!v h5T585555555 ,#vT#v8#v#v#v#v ,:Vl
t65T585555 ,yt'T
kd$$IfTl
`|T8,
t06$$$$44
layt'T}$$If!vh5T55$ #vT#v#v$ :Vl
t65T55$ yt'T}$$If!vh5T585#vT#v8#v:Vl
t65T585yt'T$$If!vh5T585#vT#v8#v:Vl
t65T585//yt'T$$If!v h5T585555555 ,#vT#v8#v#v#v#v ,:Vl
t65T585555 ,//yt'T
kd $$IfTl
`|T8,
t06$$$$44
layt'T}$$If!vh5T55$ #vT#v#v$ :Vl
t65T55$ yt'T$$If!vh5T585#vT#v8#v:Vl
t65T585//yt'T$$If!v h5T585555555 ,#vT#v8#v#v#v#v ,:Vl
t65T585555 ,//yt'T
kd1
$$IfTl
`|T8,
t06$$$$44
layt'T}$$If!vh5T55$ #vT#v#v$ :Vl
t65T55$ yt'T$$If!vh5T585#vT#v8#v:Vl
t65T585//yt'T$$If!v h5T585555555 ,#vT#v8#v#v#v#v ,:Vl
t65T585555 ,//yt'T
kdL$$IfTl
`|T8,
t06$$$$44
layt'T}$$If!vh5T55$ #vT#v#v$ :Vl
t65T55$ yt'T$$If!vh5T585#vT#v8#v:Vl
t65T585//yt'T$$If!v h5T585555555 ,#vT#v8#v#v#v#v ,:Vl
t65T585555 ,//yt'T
kdg$$IfTl
`|T8,
t06$$$$44
layt'T}$$If!vh5T55$ #vT#v#v$ :Vl
t65T55$ yt'T$$If!vh5T585#vT#v8#v:Vl
t65T585//yt'T$$If!v h5T585555555 ,#vT#v8#v#v#v#v ,:Vl
t65T585555 ,//yt'T
kd$$IfTl
`|T8,
t06$$$$44
layt'T}$$If!vh5T55$ #vT#v#v$ :Vl
t65T55$ yt'T$$If!vh5T585#vT#v8#v:Vl
t65T585//yt'T$$If!v h5T585555555 ,#vT#v8#v#v#v#v ,:Vl
t65T585555 ,//yt'T
kd$$IfTl
`|T8,
t06$$$$44
layt'T}$$If!vh5T55$ #vT#v#v$ :Vl
t65T55$ yt'T$$If!v h555555555 #v#v :Vl
t655 ytFTkd!$$IfTl d4 tD
t06$$$$44
laytFT$$If!v h555555555 #v#v :Vl
t655 ytFTkd#$$IfTl d4 tD
t06$$$$44
laytFT$$If!vh55555#v#v#v#v#v:Vl
t655555ytdT$$If!vh55555#v#v#v#v#v:Vl
t655555ytdT$$If!vh5<58555855#v<#v8#v#v#v8#v:Vl
t65<5855585ytdT$$If!vh5<58555855#v<#v8#v#v#v8#v:Vl
t65<5855585ytdT$$If!vh5<58555855#v<#v8#v#v#v8#v:Vl
t65<5855585ytdT$$If!vh5<58555855#v<#v8#v#v#v8#v:Vl
t65<5855585ytdT$$If!vh55585#v#v#v8#v:Vl
t655585yte$$If!vh55585#v#v#v8#v:Vl
t655585yte$$If!vh55585#v#v#v8#v:Vl
t655585yte$$If!vh55585#v#v#v8#v:Vl
t655585yte$$If!vh55585#v#v#v8#v:Vl
t655585yte$$If!vh55585#v#v#v8#v:Vl
t655585yte$$If!vh55585#v#v#v8#v:Vl
t655585yte$$If!vh55585#v#v#v8#v:Vl
t655585yte$$If!vh55585#v#v#v8#v:Vl
t655585yteg$$If!vh5
5T#v
#vT:Vl
t65
5Tyt$qT}$$If!vh5X5p5T#vX#vp#vT:Vl
t65X5p5Tyt$qT$$If!vh55
585#v#v
#v8#v:Vl
t655
585yti$$If!vh55
585#v#v
#v8#v:Vl
t655
585yti$$If!vh55
585#v#v
#v8#v:Vl
t655
585yti$$If!vh55
585#v#v
#v8#v:Vl
t655
585yti$$If!vh55
585#v#v
#v8#v:Vl
t655
585yti$$If!vh55
585#v#v
#v8#v:Vl
t655
585yt-[$$If!vh55
585#v#v
#v8#v:Vl
t655
585yt-[$$If!vh55
585#v#v
#v8#v:Vl
t655
585yt-[$$If!vh55
585#v#v
#v8#v:Vl
t655
585yt-[$$If!vh55
585#v#v
#v8#v:Vl
t655
585yt-[$$If!vh55
585#v#v
#v8#v:Vl
t655
585yt-[$$If!vh55
585#v#v
#v8#v:Vl
t655
585yt-[$$If!vh55
585#v#v
#v8#v:Vl
t655
585yt-[$$If!vh55
585#v#v
#v8#v:Vl
t655
585yt-[$$If!vh55
585#v#v
#v8#v:Vl
t655
585yt-[@@@NormalCJ_HaJmH sH tH DA@DDefault Paragraph FontRi@RTable Normal4
l4a(k(No List4@45vHeader
!4 @45vFooter
!.)@.5vPage Numberj@#j!t
Table Grid7:V0T;T) d'%+C
u
P
/x|T}{_foiO} !!!!""""+"-"D"M"N"_"a"x"""""""""#$%.&''(((((((((((((((()&)'))*y,,<-q-.h/n/s/////////////////00d0h11111111111111111111{22]3444(4)4/41434547494;4=4?4@4J4L4N4O4.55n67T78888 8&8(8*8,8.80828486878A8C8E8F889999999999999999999:;;;;;;;;;;;;;;;;;;;x==>>>'?%@&@[BB"C{DDDaEF;FoFFPHIIVKLxMO_PPPPPQQQQ QQQQQQQQ!Q$Q'Q*Q+QRSTTVWWKXX[YYZfZZZZZZZ[[[[[[[I[[[1\n\s\y\\\\\\\\\\\\\\\]]^S__@`}`````````````````ab4ccccc3doddde\eeFfff{ggggggggggggggggghh"h#h'hEhHhNhOhRhlhoh|h}hhhhhhhhhhhhiii
ijjk k+k,k5kJkWkXkkkl3mn9ooooop;phpjppppq/qaqqqqqq$rQr~rrrrrs~~DGLYZbekt6~KNTVW_ciqstwx}i!*M***/0&1q57799{:/<N<@0@F@AACCxEQYfbbcIcddddhhhhooo"pNp|pppq sWsvz~~~,U68҃DqƄyLOPQRSUXYZ[\]^`abdefghjklmnopruvyz{|}~M!@)4A)4B)tC)TD)"" "^^"""^^:*urn:schemas-microsoft-com:office:smarttagsStreet;*urn:schemas-microsoft-com:office:smarttagsaddress9*urn:schemas-microsoft-com:office:smarttagsplace=*urn:schemas-microsoft-com:office:smarttags PlaceName=*urn:schemas-microsoft-com:office:smarttags PlaceType#&'&(&,&]'a'--,-0-1-5-6-:-#5'5(5,58888cNgNOOOOOO,R0R1R5Rab
N
]
QVDJ O Q | <****>.C.[1f1 66=7S7':+:C>K>>>[BpBBBBBBBBBDDEEaEhEFF;FBFoFvFHHUUWWPXSXXXaYdYYYZZb\e\^^Y_\_q`t`bb4ccccccdd@dBdodzddddd5e>edeseeel2mnnoooooop pIpKpppppqq=q?qqqr
r-r6r_rarrrrrs!sJsLsssssss-t1twwyyAC3333333333333333333333333333333333333333333333333333333333333333333333333333333334|_!""M"N""""""(')h//114O48F899n::;;JJK6LP+QZ[n\\}``ccXg
ikXkoopDpssvVwrx9yyy$||^Wq`ba
1F6desku1 FAF.n m$(+=,{r-/y3FU4`u9j=<)BFBH"Q)vQ|Q: UNUi]k`f.c"i
j$qsu5v-0|~ed'V{6i+>n-[jt[|Md!t
=b*{CV4xniKs
JVE=F3]{er/9\jwk
VPC-".%=H^j4peq_fo!!""""+"-"D"M"N"_"a"x""""""""(((((((((((((((()&)')h/n/s/////////////////1111111111111111111444(4)4/41434547494;4=4?4@4J4L4N4O48888 8&8(8*8,8.80828486878A8C8E8F89999999999999999999;;;;;;;;;;;;;;;;;;;PPPPQQQQ QQQQQQQQ!Q$Q'Q*Q+QZZZZZZ[[[[[[[n\s\y\\\\\\\\\\\\\\\}`````````````````{ggggggggggggggggghh"h#h'hEhHhNhOhRhlhoh|h}hhhhhhhhhhhhiii
ik k+k,k5kJkWkXkvvvvvvvvvvvvvvwww#w&w,w-w1wLwOwUwVwrx{xxxxxxxxxxxxxxxxyyyyy/y2y8y9y$|-|4|;|D|E|H|a|d|q|r|u|||||||||||||||@8`@UnknownGz Times New Roman5Symbol3&z Arial?5 z Courier New"1hzZ5&=J wG wG%42QHX ?NU2(Chapter 13: Handling Floating Point DataEdward L. Bosworth, Ph.D.Edward L. Bosworth, Ph.D.Oh+'0( LX
x
,Chapter 13: Handling Floating Point DataEdward L. Bosworth, Ph.D.Normal.dotEdward L. Bosworth, Ph.D.61Microsoft Office Word@<.@7@tA w՜.+,0(hp
Columbus State UniversityG')Chapter 13: Handling Floating Point DataTitle
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
Root Entry FAData
]91Table_nWordDocumentoTSummaryInformation(DocumentSummaryInformation8CompObjq
FMicrosoft Office Word Document
MSWordDocWord.Document.89q~~