FLOATING POINT ARITHMETIC

1
FLOATING POINT ARITHMETIC
2

• TOPICS
• Binary representation of floating point Numbers
• Computer representation of floating point numbers
• Floating point instructions

3

• BINARY REPRESENTATION OF FLOATING POINT NUMBERS
• Converting decimal fractions into binary
  representation.
• Consider a decimal fraction of the form
  0.d1d2...dn
• We want to convert this to a binary fraction of
  the form
• 0.b1b2...bn (using binary digits instead of
  decimal digits)

4

• Algorithm for conversion
• Let X be a decimal fraction 0.d1d2..dni 1
• Repeat until X 0 or i required no. of binary
  fractional digits
•     Y X 2    X fractional part of Y    Bi
  integer part of Y
• i i 1

5

• EXAMPLE 1
• Convert 0.75 to binary
• X 0.75    (initial value)
• X 2 1.50. Set b1 1, X 0.5
• X 2 1.0. Set b2 1, X 0.0
• The binary representation for 0.75 is thus
•     0.b1b2 0.11b

6

• Let's consider what that means...    
• In the binary representation
• 0.b1b2...bm        
• b1 represents 2-1 (i.e., 1/2)
• b2 represents 2-2 (i.e., 1/4)        
•             ...        
• bm represents 2-m (1/(2m))
• So, 0.11 binary represents        
• 2-1 2-2 1/2 1/4 3/4 0.75

7

• EXAMPLE 2
• Convert the decimal value 4.9 into binary
•    
• Part 1 convert the integer part into binary    
  4 100b

8

• Part 2.
• Convert the fractional part into binary using
  multiplication by 2
• X .92 1.8. Set b1 1, X 0.8
• X2 1.6. Set b2 1, X 0.6
• X2 1.2. Set b3 1, X 0.2
• X2 0.4. Set b4 0, X 0.4
• X2 0.8. Set b5 0, X 0.8,
• which repeats from the first line above.

9

• Since X is now repeating the value 0.8,
• we know the representation will repeat.          
  
•        
• The binary representation of 4.9 is thus
• 100.111001110011100...

10

• COMPUTER REPRESENTATION OF FLOATING POINT NUMBERS
• In the CPU, a 32-bit floating point number is
  represented using IEEE standard format as
  follows
• S EXPONENT MANTISSA
• where S is one bit, the EXPONENT is 8 bits, and
  the MANTISSA is 23 bits.

11

• The mantissa represents the leading significant
  bits in the number.
• The exponent is used to adjust the position of
  the binary point (as opposed to a "decimal"
  point)  

12

• The mantissa is said to be normalized when it is
  expressed as a value between 1 and 2. I.e., the
  mantissa would be in the form 1.xxxx.

13

• The leading integer of the binary representation
  is not stored.  Since it is always a 1, it can be
  easily restored.

14

• The "S" bit is used as a sign bit and indicates
  whether the value represented is positive or
  negative.

15

• If a number is smaller than 1, normalizing the
  mantissa will produce a negative exponent.
• But 127 is added to all exponents in the floating
  point representation, allowing all exponents to
  be represented by a positive number.

16

• Example 1. Represent the decimal value 2.5 in
  32-bit floating point format.
• 2.5 10.1b
• In normalized form, this is 1.01 21
• The mantissa M 01000000000000000000000
• (23 bits without the leading 1)
• The exponent E 1 127 128 10000000b
• The sign S 0 (the value stored is positive)
• So, 2.5 01000000001000000000000000000000 

17

• Example 2 Represent the number -0.00010011b in
  floating point form.
• 0.00010011b 1.0011 2-4
• Mantissa M 00110000000000000000000 (23 bits
  with the integral 1 not represented)
• Exponent E -4 127 01111011b
• S 1 
• Result 1 01111011 00110000000000000000000

18

• Exercise 1 represent -0.75 in floating point
  format.
• Exercise 2 represent 4.9 in floating point
  format.

19

• FLOATING POINT INSTRUCTIONS
• Floating point Architecture      
• 8  80-bit stack registers ST(0), ST(1),
  ..,ST(7) (ST(0) can be abbreviated as
  ST)
• To use the floating point stack, we
• Push data from memory onto the stack
• Process data
• Pop data from stack to memory.

20

• Some floating point instructions

INSTRUCTION DESCRIPTION
Push and pops
FLD, FSTP Push and pop floating point data
FILD, FISTP Push and pop integer data

Arithmetic In all 4 cases below, the stack is popped subsequently. So the ST(1) shown becomes ST(0)
FADD ST(1) ST(0) ST(1)
FSUB ST(1) ST(0) - ST(1)
FMUL ST(1) ST(0) ST(1)
FDIV ST(1) ST(0) / ST(1)






21
Trigonometry
FSIN ST(0) sine of ST(0) radians
FCOS ST(0) cosine of ST(0) radians
FTAN ST(0) tan of ST(0) radians
FLDPI Push value of ? onto stack
22

• Example 1.
• X DW 3.4
•   Y DW 2 'This is an integer, while 2.0
  is flt. pt.
•   Z DW ? 
•  To evaluate Z X Y
•   FLD X         'ST(0) X
•   FILD Y         'ST(0) Y, ST(1) Y
•   FADD           'ST(0) X Y
•   FSTP Z         'Z X Y 

23

• Example 2. To evaluate X Y - U / V
• X DD 3.9
• Y DD 2.8
• U DD 7.3
• V DD 4.62 'code follows
• FLD U 'st(0) U
• FLD V 'st(0) V, st(1) U
• FDIV 'st(0) U / V
• FLD X 'st(0) X, st(1) U / V
• FLD Y 'st(0) Y, st(1) X, st(2) U / V
  FMUL 'st(0) Y X, st(1) U / V
• FSUB 'st(0) Y X - U / V
• FSTP Z 'Z result, st(0) empty

24

• Util.lib contains the following subroutines for
  inputting and outputting floating point numbers
•     GetFP        This inputs a no. such as 33 or
  3.56 from the keyboard, and pushes it, in binary
  floating point form, onto the stack.
•     PutFP       This pops the floating point
  number from the top of the stack, and outputs it
  in ascii.

25

• Note
• The example following assumes that you have a
  copy of mymacros.txt in your masm615/programs
  directory, and that, if the program in the
  example is named circle.asm, you compile the
  program using
• ml circle.asm util.lib

26

• Example 3. Calculating Area of a Circle
• title calculation area of circle with
  inputted radius
• extrn getfpnear, putfpnear
• include mymacros.txt
• .model small
• .stack 100h
• .data
• radius dd ?
• .386
• .code
• circle proc
• startup

27

• display "Enter the radius "
• call getfp 'could have used the macro
  inftp
• fstp radius
• fld radius
• fld radius
• instead of the above 3 instructions, we could
  have
• used fld st(0) or simply fld st
• fmul
• fldpi
• fmul
• display "The area of the circle is "
• call putfp 'could have used the macro
  outftp
• endup
• circle endp
• end circle

28

• ADDITIONAL FLOATING POINT INSTRUCTIONS
• In declaring a floating point variable use
  real4 rather than dd, e.g.
• num real4 7.3count real4 ?

29

• fabs replaces st (i.e. st(0)) by its absolute
  value
• fsqrt replaces st by its square root
• frndint rounds st up or down to the nearest
  integer

30

• We have already covered fadd used without
  arguments.
• Given,e.g.m real4 3.6n dd 21
• fadd m will set st(0) st(0) m
• fiadd m will do the same after converting the
  integer n to floating point
• fadd st(3) will set st(0) st(0) st(3)

31

• The same variations apply to
• fmul
• fdiv fld
• e.g fld stwill push the value of st onto
  the stack, so now the top two members of the
  stack will have this value.