1. Morgan Kaufmann Publishers
17 April, 2017
Lecture Oct 12
Floating-point numbers
Circuits for floating-point operations
Chapter 3 — Arithmetic for Computers

2. Morgan Kaufmann Publishers
17 April, 2017
Floating-point Representation - Basics
Floating-point numbers - provide a dynamic range of representable real numbers
Want to represent very large numbers and very small numbers
More importantly, we want to represent moderate size numbers (like p or e) with great precision.
Representation - similar to scientific notation
Chapter 3 — Arithmetic for Computers

3. Floating Point Standard
Morgan Kaufmann Publishers
17 April, 2017
Floating Point Standard
Defined by IEEE Std
Developed in response to divergence of representations
Portability issues for scientific code
Now almost universally adopted
Two representations
Single precision (32-bit)
Double precision (64-bit)
Chapter 3 — Arithmetic for Computers

4. Morgan Kaufmann Publishers
17 April, 2017
Two parts - significand (or mantissa) M and exponent (or characteristic) E
The floating-point number F represented by the pair (M,E) has the value -
F=ME ( - base of exponent)
Base - common to all numbers in a given system - implied - not included in the representation of a floating point number
Chapter 3 — Arithmetic for Computers

5. Morgan Kaufmann Publishers
17 April, 2017
Example Floating Point Format
• M = largest possible exponent, m = smallest possible exponent
• Smallest number is 1/8, Largest number is 7/4
• Smallest gap is 1/32
• Largest gap is 1/4
Chapter 3 — Arithmetic for Computers

6. IEEE 754 floating-point standard
Morgan Kaufmann Publishers
17 April, 2017
IEEE 754 floating-point standard
Leading “1” bit of significand is implicit
Exponent is “biased” to make sorting easier
all 0s is smallest exponent all 1s is largest
bias of 127 for single precision and 1023 for double precision
summary: (–1)sign x (1+significand) x 2exponent – bias
Example:
decimal: = - ( ½ + ¼ )
binary: = -1.1 x 2-1
floating point: exponent = 126 =
IEEE single precision:
Chapter 3 — Arithmetic for Computers

7. IEEE Floating-Point Format
Morgan Kaufmann Publishers
17 April, 2017
IEEE Floating-Point Format
single: 8 bits double: 11 bits
single: 23 bits double: 52 bits S
Exponent
Fraction
S: sign bit (0  non-negative, 1  negative)
Normalize significand: 1.0 ≤ |significand| < 2.0
Always has a leading pre-binary-point 1 bit, so no need to represent it explicitly (hidden bit)
Significand is Fraction with the “1.” restored
Exponent: excess representation: actual exponent + Bias
Ensures exponent is unsigned
Single: Bias = 127; Double: Bias = 1023
Chapter 3 — Arithmetic for Computers

8. Morgan Kaufmann Publishers
17 April, 2017
Precision
n bits partitioned into two parts - significand M and exponent E
n bits – 2n different values
Range between smallest and largest representable values increases  distance between any two consecutive values increases
Floating-point numbers sparser than fixed-point numbers - lower precision
Real number between two consecutive floating-point numbers is mapped onto one of the two
A larger distance between two consecutive numbers results in a lower precision of representation
Chapter 3 — Arithmetic for Computers

9. Morgan Kaufmann Publishers
17 April, 2017
Example: What decimal representation of real number is represented by the following 32 bit string (in IEEE format)?
… 0
Answer: Exponent is 210 (=12910 – 12710)
Sign is negative.
Significand value is ( …)2 =
Value of the number is –(22 x 1.25)10 = - 510
Chapter 3 — Arithmetic for Computers

10. Morgan Kaufmann Publishers
17 April, 2017
Design choices for FP format
Recall that significand (mantissa) uses sign-magnitude format, exponent uses excess notation.
Choices mainly motivated by need to compare two FP numbers very quickly.
Order relation is determined by comparing the exponents first.
Chapter 3 — Arithmetic for Computers

11. Morgan Kaufmann Publishers
17 April, 2017
Normalized and denormalized numbers
If the exponent is between 1 and 254, a normal real number is represented.
If the exponent is 0:
if significand is 0, then value = 0.
if significand is not zero, it represents a denormalized number.
b1 b2 … b23 represents 0. b1 b2 … b23 rather than
1.b1b2 … b23
Why? To reduce the chance of underflow.
Chapter 3 — Arithmetic for Computers

12. Morgan Kaufmann Publishers
17 April, 2017
Nonstandard numbers
When the exponent is 255, the number represented is
+ or – infinity (if the significand is 0)
NaN (otherwise)
Example: What do the following numbers represent? …0 …0
Answer: The first one represents 0.510
The second one represents
Chapter 3 — Arithmetic for Computers

13. Morgan Kaufmann Publishers
17 April, 2017
Set of representable numbers using FP format
The number of distinct normal numbers that can be represented using a single-precision floating point format is 232 – 224.
Reason: There are no ambiguous representations, i.e., two distinct 32 bits representing normal numbers represent two distinct real numbers.
Main advantage of double precision FP format is that it can represent “typical” real numbers more precisely.
The expanded range of representable numbers (upto 2.0 x 10308) is less important.
Chapter 3 — Arithmetic for Computers

14. Morgan Kaufmann Publishers
17 April, 2017
Absolute and relative error in FP representation
A real number r in the range
-2127 x( ) <= r <= 2127 x( )
is either representable (exactly), or there exist two representable real numbers r1 and r2 such that r1 < r < r2.
r should be represented as r1 (if |r – r1| < |r – r2|) or r2 (otherwise).
The (absolute) error is |r – r’| where r is the real number being represented, and r’ is the chosen representation.
Relative error is |r – r’|/|r’|
Chapter 3 — Arithmetic for Computers

15. Morgan Kaufmann Publishers
17 April, 2017
Problem: Show the representation of the following decimal numbers in the ANSI/IEEE short and long floating-point formats. When the number is not exactly representable, use the round to nearest even rule.
–6.25
Chapter 3 — Arithmetic for Computers

16. Morgan Kaufmann Publishers
17 April, 2017
Problem: Show the representation of the following decimal numbers in the ANSI/ISSS short and long floating-point formats. When the number is not exactly representable, use the round to nearest even rule.
–6.25
Answer: sign bit is 1
6.25 = 22 x = … 0
This is exact representation.
Chapter 3 — Arithmetic for Computers

17. Morgan Kaufmann Publishers
17 April, 2017
Problem: What are the absolute and relative errors in the representation of the real number ? (Use the standard rounding rule.)
FP representation of r = 0.1 is
r1 = (in base 2)
r1 = (in base 10)
Absolute error is ~
Relative error is ~ = 9 x 10-7
Relative error is more or less independent of the actual value of the number.
Chapter 3 — Arithmetic for Computers

18. Morgan Kaufmann Publishers
17 April, 2017
Relative error for a large number
Example: Consider a large number, e.g What is its FP representation? What is the relative error in its representation?
Chapter 3 — Arithmetic for Computers

19. Morgan Kaufmann Publishers
17 April, 2017
Relative error associated with a large number
Example: Consider a large number, e.g What is its FP representation? What is the relative error in its representation?
Solution:
Step 1: Write 1035 as 1035 = 2E y where y is in [1, 2).
Step 2: Write E in excess 127 notation.
Step 3: Write y – 1 in base ½. 5
Chapter 3 — Arithmetic for Computers

20. Morgan Kaufmann Publishers
17 April, 2017
Step 1: Write 1035 as 1035 = 2E y where y is in [1, 2).
We can compute E using the c++ code:
E = 1; val = 2.0;
while (val < 1.0E35) {
val *= 2;
E++; }
E--;
y = 1.0E35/val;
The values of E and y are computed as follows:
E = 116
y =
Chapter 3 — Arithmetic for Computers

21. Morgan Kaufmann Publishers
17 April, 2017
Step 2: Write E = 116 in excess 127 notation.
Step 3: Write y – 1 in base ½.
y – 1 =
Converting y – 1 in binary:
x 2 = < 1 so first bit is 0
x 2 = < 1 so second bit is 0
x 2 = > 1 so 3rd bit is 1
– 1 =
x 2 = > 1 so 4th bit is 1 etc.
The final result (correct to 23 bits is):
The FP representation of x = 1035 is
y =
Chapter 3 — Arithmetic for Computers

22. Morgan Kaufmann Publishers
17 April, 2017
Relative error in the FP representation of 1035
Let x = 1035 and y be the number whose FP representation is
What is (the value of) y?
y ~ x 1035
Relative error is |x – y|/ x ~ x 10-9
Chapter 3 — Arithmetic for Computers

23. Morgan Kaufmann Publishers
17 April, 2017
Why is the integer not exactly representable?
Slide source: UIUC, CS 232 class lecture
Chapter 3 — Arithmetic for Computers

24. Effect of Loss of Precision
Morgan Kaufmann Publishers
17 April, 2017
Effect of Loss of Precision
According to the General Accounting Office of the U.S. Government, a loss of precision in converting 24- bit integers into 24-bit floating point numbers was responsible for the failure of a Patriot anti- missile battery.
Chapter 3 — Arithmetic for Computers

25. Morgan Kaufmann Publishers
Effect of Loss of Precision
Morgan Kaufmann Publishers
17 April, 2017
Slide source: UIUC, CS 232 class lecture
Chapter 3 — Arithmetic for Computers

26. Morgan Kaufmann Publishers
17 April, 2017
Denormal Numbers
Exponent =  hidden bit is 0
Smaller than normal numbers
allow for gradual underflow, with diminishing precision
Denormal with fraction =
Two representations of 0.0
Chapter 3 — Arithmetic for Computers

27. Morgan Kaufmann Publishers
17 April, 2017
Infinities and NaNs
Exponent = , Fraction =
±Infinity
Can be used in subsequent calculations, avoiding need for overflow check
Exponent = , Fraction ≠
Not-a-Number (NaN)
Indicates illegal or undefined result
e.g., 0.0 / 0.0
Can be used in subsequent calculations
Chapter 3 — Arithmetic for Computers

28. Floating-Point Addition
Morgan Kaufmann Publishers
17 April, 2017
Floating-Point Addition
Consider a 4-digit decimal example
9.999 × × 10–1
1. Align decimal points
Shift number with smaller exponent
9.999 × × 101
2. Add significands
9.999 × × 101 = × 101
3. Normalize result & check for over/underflow
× 102
4. Round and renormalize if necessary
1.002 × 102
Chapter 3 — Arithmetic for Computers

29. Floating-Point Addition
Morgan Kaufmann Publishers
17 April, 2017
Floating-Point Addition
Now consider a 4-digit binary example
× 2–1 + – × 2–2 (0.5 + –0.4375)
1. Align binary points
Shift number with smaller exponent
× 2–1 + – × 2–1
2. Add significands
× 2–1 + – × 2–1 = × 2–1
3. Normalize result & check for over/underflow
× 2–4, with no over/underflow
4. Round and renormalize if necessary
× 2–4 (no change) =
Chapter 3 — Arithmetic for Computers

30. Morgan Kaufmann Publishers
17 April, 2017
FP Adder Hardware
Much more complex than integer adder
Doing it in one clock cycle would take too long
Much longer than integer operations
Slower clock would penalize all instructions
FP adder usually takes several cycles
Can be pipelined
Chapter 3 — Arithmetic for Computers

31. Floating point addition
Morgan Kaufmann Publishers
17 April, 2017
Floating point addition
Chapter 3 — Arithmetic for Computers

32. Morgan Kaufmann Publishers
17 April, 2017
FP Adder Hardware
Step 1
Step 2
Step 3
Step 4
Chapter 3 — Arithmetic for Computers

33. Morgan Kaufmann Publishers
17 April, 2017
Addition and Subtraction
Exponents of both operands must be equal before adding or subtracting significands
Significands aligned by shifting the significand of the smaller operand |E1-E2| base- positions to the right, increasing its exponent, until exponents are equal
E1E2 -
Exponent of larger number not decreased - this will result in a significand larger than 1 - a larger significand adder required
Chapter 3 — Arithmetic for Computers

34. Morgan Kaufmann Publishers
17 April, 2017
Addition/Subtraction – post-normalization
Addition - resultant significand M (sum of two aligned significands) is in range 1/  M < 2
If M>1 - a postnormalization step - shifting significand to the right to yield M3 and increasing exponent by one - is required (an exponent overflow may occur)
Subtraction - Resultant significand M is in range 0  |M|< 1 - postnormalization step - shifting significand to left and decreasing exponent - is required if M<1/ (an exponent underflow may occur)
In extreme cases, the postnormalization step may require a shift left operation over all bits in significand, yielding a zero result
Chapter 3 — Arithmetic for Computers

35. Morgan Kaufmann Publishers
17 April, 2017
Example
F1=( )16  163 ; F2=(0.FFFFFF)16  162
Short IBM format ; calculate F1 – F2
Significand of smaller number (F2) is shifted to the right - least-significant digit lost
Shift is time consuming - result is wrong
Chapter 3 — Arithmetic for Computers

36. Morgan Kaufmann Publishers
17 April, 2017
Example - Continued
Correct result (with “unlimited" number of significand digits)
Error (also called loss of significance) is   = 0.F  16-3
Solution to problem - guard digits - additional digits to the right of the significand to hold shifted-out digits
In example - a single (hexadecimal) guard digit is sufficient
Chapter 3 — Arithmetic for Computers

37. Morgan Kaufmann Publishers
17 April, 2017
Steps in Addition/Subtraction of Floating-Point Numbers
Step 1: Calculate difference d of the two exponents - d=|E1 - E2|
Step 2: Shift significand of smaller number by d base- positions to the right
Step 3: Add aligned significands and set exponent of result to exponent of larger operand
Step 4: Normalize resultant significand and adjust exponent if necessary
Step 5: Round resultant significand and adjust exponent if necessary
Chapter 3 — Arithmetic for Computers

38. Floating Point Complexities
Morgan Kaufmann Publishers
17 April, 2017
Floating Point Complexities
Operations are somewhat more complicated (see text)
In addition to overflow we can have “underflow”
Accuracy can be a big problem
IEEE 754 keeps two extra bits, guard and round
four rounding modes
positive divided by zero yields “infinity”
zero divide by zero yields “not a number”
other complexities
Implementing the standard can be tricky
Not using the standard can be even worse
see text for description of 80x86 and Pentium bug!
Chapter 3 — Arithmetic for Computers

39. Floating-Point Multiplication
Morgan Kaufmann Publishers
17 April, 2017
Floating-Point Multiplication
Consider a 4-digit decimal example
1.110 × 1010 × × 10–5
1. Add exponents
For biased exponents, subtract bias from sum
New exponent = 10 + –5 = 5
2. Multiply significands
1.110 × =  × 105
3. Normalize result & check for over/underflow
× 106
4. Round and renormalize if necessary
1.021 × 106
5. Determine sign of result from signs of operands
× 106
Chapter 3 — Arithmetic for Computers

40. Floating-Point Multiplication
Morgan Kaufmann Publishers
Floating-Point Multiplication
17 April, 2017
Now consider a 4-digit binary example
× 2–1 × – × 2–2 (0.5 × –0.4375)
1. Add exponents
Unbiased: –1 + –2 = –3
Biased: (– ) + (– ) = – – 127 = –
2. Multiply significands
× =  × 2–3
3. Normalize result & check for over/underflow
× 2–3 (no change) with no over/underflow
4. Round and renormalize if necessary
× 2–3 (no change)
5. Determine sign: +ve × –ve  –ve
– × 2–3 = –
Chapter 3 — Arithmetic for Computers

41. FP Arithmetic Hardware
Morgan Kaufmann Publishers
FP Arithmetic Hardware
17 April, 2017
FP multiplier is of similar complexity to FP adder
But uses a multiplier for significands instead of an adder
FP arithmetic hardware usually does
Addition, subtraction, multiplication, division, reciprocal, square-root
FP  integer conversion
Operations usually takes several cycles
Can be pipelined
Chapter 3 — Arithmetic for Computers

42. FP Instructions in MIPS
Morgan Kaufmann Publishers
17 April, 2017
FP Instructions in MIPS
FP hardware is coprocessor 1
Adjunct processor that extends the ISA
Separate FP registers
32 single-precision: $f0, $f1, … $f31
Paired for double-precision: $f0/$f1, $f2/$f3, …
Release 2 of MIPs ISA supports 32 × 64-bit FP reg’s
FP instructions operate only on FP registers
Programs generally don’t do integer ops on FP data, or vice versa
More registers with minimal code-size impact
FP load and store instructions
lwc1, ldc1, swc1, sdc1
e.g., ldc1 $f8, 32($sp)
Chapter 3 — Arithmetic for Computers

43. FP Instructions in MIPS
Morgan Kaufmann Publishers
17 April, 2017
FP Instructions in MIPS
Single-precision arithmetic
add.s, sub.s, mul.s, div.s
e.g., add.s $f0, $f1, $f6
Double-precision arithmetic
add.d, sub.d, mul.d, div.d
e.g., mul.d $f4, $f4, $f6
Single- and double-precision comparison
c.xx.s, c.xx.d (xx is eq, lt, le, …)
Sets or clears FP condition-code bit
e.g. c.lt.s $f3, $f4
Branch on FP condition code true or false
bc1t, bc1f
e.g., bc1t TargetLabel
Chapter 3 — Arithmetic for Computers

44. Morgan Kaufmann Publishers
17 April, 2017
FP Example: °F to °C
C code:
float f2c (float fahr) { return ((5.0/9.0)*(fahr )); }
fahr in $f12, result in $f0, literals in global memory space
Compiled MIPS code:
f2c: lwc1 $f16, const5($gp) lwc2 $f18, const9($gp) div.s $f16, $f16, $f lwc1 $f18, const32($gp) sub.s $f18, $f12, $f mul.s $f0, $f16, $f jr $ra
Chapter 3 — Arithmetic for Computers

45. FP Example: Array Multiplication
Morgan Kaufmann Publishers
17 April, 2017
FP Example: Array Multiplication
X = X + Y × Z
All 32 × 32 matrices, 64-bit double-precision elements
C code:
void mm (double x[][], double y[][], double z[][]) { int i, j, k; for (i = 0; i! = 32; i = i + 1) for (j = 0; j! = 32; j = j + 1) for (k = 0; k! = 32; k = k + 1) x[i][j] = x[i][j] y[i][k] * z[k][j]; }
Addresses of x, y, z in $a0, $a1, $a2, and i, j, k in $s0, $s1, $s2
Chapter 3 — Arithmetic for Computers

46. FP Example: Array Multiplication
Morgan Kaufmann Publishers
17 April, 2017
FP Example: Array Multiplication
MIPS code:
li $t1, # $t1 = 32 (row size/loop end) li $s0, # i = 0; initialize 1st for loop L1: li $s1, # j = 0; restart 2nd for loop L2: li $s2, # k = 0; restart 3rd for loop sll $t2, $s0, 5 # $t2 = i * 32 (size of row of x) addu $t2, $t2, $s1 # $t2 = i * size(row) + j sll $t2, $t2, 3 # $t2 = byte offset of [i][j] addu $t2, $a0, $t2 # $t2 = byte address of x[i][j] l.d $f4, 0($t2) # $f4 = 8 bytes of x[i][j] L3: sll $t0, $s2, 5 # $t0 = k * 32 (size of row of z) addu $t0, $t0, $s1 # $t0 = k * size(row) + j sll $t0, $t0, 3 # $t0 = byte offset of [k][j] addu $t0, $a2, $t0 # $t0 = byte address of z[k][j] l.d $f16, 0($t0) # $f16 = 8 bytes of z[k][j] …
Chapter 3 — Arithmetic for Computers

47. FP Example: Array Multiplication
Morgan Kaufmann Publishers
17 April, 2017
FP Example: Array Multiplication
… sll $t0, $s0, # $t0 = i*32 (size of row of y) addu $t0, $t0, $s2 # $t0 = i*size(row) + k sll $t0, $t0, # $t0 = byte offset of [i][k] addu $t0, $a1, $t0 # $t0 = byte address of y[i][k] l.d $f18, 0($t0) # $f18 = 8 bytes of y[i][k] mul.d $f16, $f18, $f16 # $f16 = y[i][k] * z[k][j] add.d $f4, $f4, $f16 # f4=x[i][j] + y[i][k]*z[k][j] addiu $s2, $s2, # $k k bne $s2, $t1, L3 # if (k != 32) go to L3 s.d $f4, 0($t2) # x[i][j] = $f4 addiu $s1, $s1, # $j = j bne $s1, $t1, L2 # if (j != 32) go to L2 addiu $s0, $s0, # $i = i bne $s0, $t1, L1 # if (i != 32) go to L1
Chapter 3 — Arithmetic for Computers

48. Morgan Kaufmann Publishers
17 April, 2017
Accurate Arithmetic
IEEE Std 754 specifies additional rounding control
Extra bits of precision (guard, round, sticky)
Choice of rounding modes
Allows programmer to fine-tune numerical behavior of a computation
Not all FP units implement all options
Most programming languages and FP libraries just use defaults
Trade-off between hardware complexity, performance, and market requirements
Chapter 3 — Arithmetic for Computers

49. Interpretation of Data
Morgan Kaufmann Publishers
17 April, 2017
Interpretation of Data
The BIG Picture
Bits have no inherent meaning
Interpretation depends on the instructions applied
Computer representations of numbers
Finite range and precision
Need to account for this in programs
Chapter 3 — Arithmetic for Computers

50. Morgan Kaufmann Publishers
17 April, 2017
Associativity
Parallel programs may interleave operations in unexpected orders
Assumptions of associativity may fail
§3.6 Parallelism and Computer Arithmetic: Associativity
Need to validate parallel programs under varying degrees of parallelism
Chapter 3 — Arithmetic for Computers

51. Morgan Kaufmann Publishers
17 April, 2017
x86 FP Architecture
Originally based on 8087 FP coprocessor
8 × 80-bit extended-precision registers
Used as a push-down stack
Registers indexed from TOS: ST(0), ST(1), …
FP values are 32-bit or 64 in memory
Converted on load/store of memory operand
Integer operands can also be converted on load/store
Very difficult to generate and optimize code
Result: poor FP performance
§3.7 Real Stuff: Floating Point in the x86
Chapter 3 — Arithmetic for Computers

52. Morgan Kaufmann Publishers
17 April, 2017
x86 FP Instructions
Data transfer
Arithmetic
Compare
Transcendental
FILD mem/ST(i)
FISTP mem/ST(i)
FLDPI
FLD1
FLDZ
FIADDP mem/ST(i)
FISUBRP mem/ST(i) FIMULP mem/ST(i) FIDIVRP mem/ST(i)
FSQRT
FABS
FRNDINT
FICOMP
FIUCOMP
FSTSW AX/mem
FPATAN
F2XMI
FCOS
FPTAN
FPREM
FPSIN
FYL2X
Optional variations
I: integer operand
P: pop operand from stack
R: reverse operand order
But not all combinations allowed
Chapter 3 — Arithmetic for Computers

53. Streaming SIMD Extension 2 (SSE2)
Morgan Kaufmann Publishers
17 April, 2017
Streaming SIMD Extension 2 (SSE2)
Adds 4 × 128-bit registers
Extended to 8 registers in AMD64/EM64T
Can be used for multiple FP operands
2 × 64-bit double precision
4 × 32-bit double precision
Instructions operate on them simultaneously
Single-Instruction Multiple-Data
Chapter 3 — Arithmetic for Computers

54. Right Shift and Division
Morgan Kaufmann Publishers
17 April, 2017
Right Shift and Division
Left shift by i places multiplies an integer by 2i
Right shift divides by 2i?
Only for unsigned integers
For signed integers
Arithmetic right shift: replicate the sign bit
e.g., –5 / 4
>> 2 = = –2
Rounds toward –∞
c.f >>> 2 = = +62
§3.8 Fallacies and Pitfalls
Chapter 3 — Arithmetic for Computers

55. Who Cares About FP Accuracy?
Morgan Kaufmann Publishers
17 April, 2017
Who Cares About FP Accuracy?
Important for scientific code
But for everyday consumer use?
“My bank balance is out by ¢!” 
The Intel Pentium FDIV bug
The market expects accuracy
See Colwell, The Pentium Chronicles
Chapter 3 — Arithmetic for Computers

56. Morgan Kaufmann Publishers
17 April, 2017
Concluding Remarks
ISAs support arithmetic
Signed and unsigned integers
Floating-point approximation to reals
Bounded range and precision
Operations can overflow and underflow
MIPS ISA
Core instructions: 54 most frequently used
100% of SPECINT, 97% of SPECFP
Other instructions: less frequent
§3.9 Concluding Remarks
Chapter 3 — Arithmetic for Computers

57. Floating-point numbers
Morgan Kaufmann Publishers
17 April, 2017
Floating-point numbers
Denormals allow graceful underflow
Distribution of floating-point numbers on the real line.
Chapter 3 — Arithmetic for Computers

58. Morgan Kaufmann Publishers
17 April, 2017
Floating Point
§3.5 Floating Point
Representation for non-integral numbers
Including very small and very large numbers
Like scientific notation
–2.34 × 1056
× 10–4
× 109
In binary
±1.xxxxxxx2 × 2yyyy
Types float and double in C
normalized
not normalized
Chapter 3 — Arithmetic for Computers

59. Single-Precision Range
Morgan Kaufmann Publishers
17 April, 2017
Single-Precision Range
Exponents and reserved
Smallest value
Exponent:  actual exponent = 1 – 127 = –126
Fraction: 000…00  significand = 1.0
±1.0 × 2–126 ≈ ±1.2 × 10–38
Largest value
exponent:  actual exponent = 254 – 127 = +127
Fraction: 111…11  significand ≈ 2.0
±2.0 × ≈ ±3.4 × 10+38
Chapter 3 — Arithmetic for Computers

60. Double-Precision Range
Morgan Kaufmann Publishers
17 April, 2017
Double-Precision Range
Exponents 0000…00 and 1111…11 reserved
Smallest value
Exponent:  actual exponent = 1 – 1023 = –1022
Fraction: 000…00  significand = 1.0
±1.0 × 2–1022 ≈ ±2.2 × 10–308
Largest value
Exponent:  actual exponent = 2046 – 1023 = +1023
Fraction: 111…11  significand ≈ 2.0
±2.0 × ≈ ±1.8 ×
Chapter 3 — Arithmetic for Computers

61. Floating-Point Precision
Morgan Kaufmann Publishers
17 April, 2017
Floating-Point Precision
Relative precision
all fraction bits are significant
Single: approx 2–23
Equivalent to 23 × log102 ≈ 23 × 0.3 ≈ 6 decimal digits of precision
Double: approx 2–52
Equivalent to 52 × log102 ≈ 52 × 0.3 ≈ 16 decimal digits of precision
Chapter 3 — Arithmetic for Computers

62. Floating-Point Example
Morgan Kaufmann Publishers
17 April, 2017
Floating-Point Example
Represent –0.75
–0.75 = (–1)1 × 1.12 × 2–1
S = 1
Fraction = 1000…002
Exponent = –1 + Bias
Single: – = 126 =
Double: – = 1022 =
Single: …00
Double: …00
Chapter 3 — Arithmetic for Computers

63. Floating-Point Example
Morgan Kaufmann Publishers
17 April, 2017
Floating-Point Example
What number is represented by the single-precision float
…00
S = 1
Fraction = 01000…002
Fxponent = = 129
x = (–1)1 × ( ) × 2(129 – 127)
= (–1) × 1.25 × 22
= –5.0
Chapter 3 — Arithmetic for Computers