Carnegie Mellon

Floa.ng  Point  
 
15-­‐213:  Introduc;on  to  Computer  Systems  
4th  Lecture,  Sep.  10,  2015  

Instructors:    
Randal  E.  Bryant  and  David  R.  O’Hallaron  

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on  

 Carnegie Mellon

Today:  Floa.ng  Point  

¢  Background:  Frac;onal  binary  numbers  
¢  IEEE  floa;ng  point  standard:  Defini;on  

¢  Example  and  proper;es  

¢  Rounding,  addi;on,  mul;plica;on  

¢  Floa;ng  point  in  C  

¢  Summary  

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   2

 Carnegie Mellon

Frac.onal  binary  numbers  

¢  What  is  1011.1012?  

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   3

 Carnegie Mellon

Frac.onal  Binary  Numbers  

2i  
2i-­‐1  

4  
• • •
2  
1  

bi   bi-­‐1   •••   b2   b1   b0   b-­‐1   b-­‐2   b-­‐3   •••   b-­‐j  

1/2  
1/4   • • •

1/8  

¢  Representa;on   2-­‐j  

§  Bits  to  right  of  “binary  point”  represent  frac;onal  powers  of  2  
§  Represents  ra;onal  number:  

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   4

 Carnegie Mellon

Frac.onal  Binary  Numbers:  Examples  

¢  Value  Representa;on  
5  3/4 101.112
2  7/8 010.1112
1  7/16 001.01112

¢  Observa;ons  
§  Divide  by  2  by  shi`ing  right  (unsigned)  
§  Mul;ply  by  2  by  shi`ing  le`  
§  Numbers  of  form  0.111111…2  are  just  below  1.0  
§  1/2  +  1/4  +  1/8  +  …  +  1/2i  +  …  ➙  1.0  
§  Use  nota;on  1.0  –  ε  

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   5

 Carnegie Mellon

Representable  Numbers  
¢  Limita;on  #1  
§  Can  only  exactly  represent  numbers  of  the  form  x/2k  
§  Other  ra;onal  numbers  have  repea;ng  bit  representa;ons  
§  Value  Representa;on  
§  1/3  0.0101010101[01]…2
§  1/5  0.001100110011[0011]…2
§  1/10  0.0001100110011[0011]…2

¢  Limita;on  #2  

§  Just  one  selng  of  binary  point  within  the  w  bits
§  Limited  range  of  numbers  (very  small  values?    very  large?)

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   6

 Carnegie Mellon

Today:  Floa.ng  Point  

¢  Background:  Frac;onal  binary  numbers  
¢  IEEE  floa;ng  point  standard:  Defini;on  

¢  Example  and  proper;es  

¢  Rounding,  addi;on,  mul;plica;on  

¢  Floa;ng  point  in  C  

¢  Summary  

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   7

 Carnegie Mellon

IEEE  Floa.ng  Point  

¢  IEEE  Standard  754  
§  Established  in  1985  as  uniform  standard  for  floa;ng  point  arithme;c  
Before  that,  many  idiosyncra;c  formats  
§ 
§  Supported  by  all  major  CPUs  

¢  Driven  by  numerical  concerns  

§  Nice  standards  for  rounding,  overflow,  underflow  
§  Hard  to  make  fast  in  hardware  
§  Numerical  analysts  predominated  over  hardware  designers  in  defining  
standard  

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   8

 Carnegie Mellon

Floa.ng  Point  Representa.on  

¢  Numerical  Form:    
     (–1)s  M    2E  
§  Sign  bit  s  determines  whether  number  is  nega;ve  or  posi;ve  
§  Significand  M    normally  a  frac;onal  value  in  range  [1.0,2.0).  
§  Exponent  E  weights  value  by  power  of  two  

¢  Encoding  
§  MSB  s  is  sign  bit  s  
§  exp  field  encodes  E  (but  is  not  equal  to  E)  
§  frac  field  encodes  M  (but  is  not  equal  to  M)  

s   exp   frac  

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   9

 Carnegie Mellon

Precision  op.ons  
¢  Single  precision:  32  bits  

s   exp   frac  

1   8-­‐bits   23-­‐bits  

¢  Double  precision:  64  bits  

s   exp   frac  

1   11-­‐bits   52-­‐bits  
¢  Extended  precision:  80  bits  (Intel  only)  

s   exp   frac  
1   15-­‐bits   63  or  64-­‐bits  
Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   10

 Carnegie Mellon

“Normalized”  Values   v = (–1)s M 2E

¢  When:  exp  ≠  000…0  and  exp  ≠  111…1  

¢  Exponent  coded  as  a  biased  value:  E    =    Exp  –  Bias  

§  Exp:  unsigned  value  of  exp  field    
§  Bias  =  2k-­‐1  -­‐  1,  where  k  is  number  of  exponent  bits  
§  Single  precision:  127  (Exp:  1…254,  E:  -­‐126…127)  
§  Double  precision:  1023  (Exp:  1…2046,  E:  -­‐1022…1023)  

¢  Significand  coded  with  implied  leading  1:  M    =    1.xxx…x2  

§   xxx…x:  bits  of  frac  field  
§  Minimum  when  frac=000…0  (M  =  1.0)  
§  Maximum  when  frac=111…1  (M  =  2.0  –  ε)  
§  Get  extra  leading  bit  for  “free”  
Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   11

 Carnegie Mellon

Normalized  Encoding  Example   v = (–1)s M 2E  

E = Exp – Bias

¢  Value:  float F = 15213.0;
§  1521310    =  111011011011012        
                                         =  1.11011011011012  x  213  

¢  Significand  
M    =    1.11011011011012
frac = 110110110110100000000002  

¢  Exponent  
E      =    13  
Bias    =    127  
Exp    =    140    =  100011002

¢  Result:  
 
0 10001100 11011011011010000000000
s   exp frac
Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   12

 Carnegie Mellon

Denormalized  Values   v = (–1)s M 2E  

E = 1 – Bias

¢  Condi;on:  exp  =  000…0  

¢  Exponent  value:  E  =  1  –  Bias  (instead  of  E  =  0  –  Bias)  

¢  Significand  coded  with  implied  leading  0:  M  =  0.xxx…x2  

§  xxx…x:  bits  of  frac  

¢  Cases  
§   exp  =  000…0,  frac  =  000…0
Represents  zero  value  
§ 
§  Note  dis;nct  values:  +0  and  –0  (why?)  
§  exp  =  000…0,  frac  ≠  000…0
§  Numbers  closest  to  0.0  
§  Equispaced  

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   13

 Carnegie Mellon

Special  Values  
¢  Condi;on:  exp  =  111…1

¢  Case:  exp  =  111…1,  frac  =  000…0

§  Represents  value  ∞  (infinity)  
§  Opera;on  that  overflows  
§  Both  posi;ve  and  nega;ve  
§  E.g.,  1.0/0.0  =  −1.0/−0.0  =  +∞,    1.0/−0.0  =  −∞  

¢  Case:  exp  =  111…1,  frac  ≠  000…0

§  Not-­‐a-­‐Number  (NaN)  
§  Represents  case  when  no  numeric  value  can  be  determined  
§  E.g.,  sqrt(–1),  ∞  −  ∞,  ∞  ×  0  

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   14

 Carnegie Mellon

Visualiza.on:  Floa.ng  Point  Encodings  

−∞   +∞  
−Normalized   −Denorm   +Denorm   +Normalized  

NaN   NaN  
-­‐0   +0  

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   15

 Carnegie Mellon

Today:  Floa.ng  Point  

¢  Background:  Frac;onal  binary  numbers  
¢  IEEE  floa;ng  point  standard:  Defini;on  

¢  Example  and  proper;es  

¢  Rounding,  addi;on,  mul;plica;on  

¢  Floa;ng  point  in  C  

¢  Summary  

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   16

 Carnegie Mellon

Tiny  Floa.ng  Point  Example  

s   exp   frac  
1   4-­‐bits   3-­‐bits  

¢  8-­‐bit  Floa;ng  Point  Representa;on  

§  the  sign  bit  is  in  the  most  significant  bit  
§  the  next  four  bits  are  the  exponent,  with  a  bias  of  7  
§  the  last  three  bits  are  the  frac  

¢  Same  general  form  as  IEEE  Format  

§  normalized,  denormalized  
§  representa;on  of  0,  NaN,  infinity  

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   17

 Carnegie Mellon

Dynamic  Range  (Posi.ve  Only)   v = (–1)s M 2E  

s exp frac E Value n:  E  =  Exp  –  Bias  
0 0000 000 -6 0 d:  E = 1 – Bias

0 0000 001 -6 1/8*1/64 = 1/512 closest  to  zero  
Denormalized   0 0000 010 -6 2/8*1/64 = 2/512
numbers   …
0 0000 110 -6 6/8*1/64 = 6/512
0 0000 111 -6 7/8*1/64 = 7/512 largest  denorm  
0 0001 000 -6 8/8*1/64 = 8/512
smallest  norm  
0 0001 001 -6 9/8*1/64 = 9/512
…
0 0110 110 -1 14/8*1/2 = 14/16
0 0110 111 -1 15/8*1/2 = 15/16 closest  to  1  below  
Normalized   0 0111 000 0 8/8*1 = 1
numbers   0 0111 001 0 9/8*1 = 9/8 closest  to  1  above  
0 0111 010 0 10/8*1 = 10/8
…
0 1110 110 7 14/8*128 = 224
0 1110 111 7 15/8*128 = 240 largest  norm  
0 1111 000 n/a inf

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   18

 Carnegie Mellon

Distribu.on  of  Values  

¢  6-­‐bit  IEEE-­‐like  format  
§  e  =  3  exponent  bits  
§  f  =  2  frac;on  bits   s   exp   frac  
§  Bias  is  23-­‐1-­‐1  =  3   1   3-­‐bits   2-­‐bits  

¢  No;ce  how  the  distribu;on  gets  denser  toward  zero.    

 8  values  

-15 -10 -5 0 5 10 15
Denormalized Normalized Infinity

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   19

 Carnegie Mellon

Distribu.on  of  Values  (close-­‐up  view)  

¢  6-­‐bit  IEEE-­‐like  format  
§  e  =  3  exponent  bits  
§  f  =  2  frac;on  bits   s   exp   frac  
§  Bias  is  3   1   3-­‐bits   2-­‐bits  

-1 -0.5 0 0.5 1
Denormalized Normalized Infinity

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   20

 Carnegie Mellon

Special  Proper.es  of  the  IEEE  Encoding  

¢  FP  Zero  Same  as  Integer  Zero  
§  All  bits  =  0  

¢  Can  (Almost)  Use  Unsigned  Integer  Comparison  

§  Must  first  compare  sign  bits  
§  Must  consider  −0  =  0  
§  NaNs  problema;c  
§  Will  be  greater  than  any  other  values  
§  What  should  comparison  yield?  
§   Otherwise  OK  
§  Denorm  vs.  normalized  
§  Normalized  vs.  infinity  

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   21

 Carnegie Mellon

Today:  Floa.ng  Point  

¢  Background:  Frac;onal  binary  numbers  
¢  IEEE  floa;ng  point  standard:  Defini;on  

¢  Example  and  proper;es  

¢  Rounding,  addi;on,  mul;plica;on  

¢  Floa;ng  point  in  C  

¢  Summary  

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   22

 Carnegie Mellon

Floa.ng  Point  Opera.ons:  Basic  Idea  

¢  x +f y = Round(x + y)

¢  x ×f y = Round(x × y)

¢  Basic  idea  

§  First  compute  exact  result  
§  Make  it  fit  into  desired  precision  
§  Possibly  overflow  if  exponent  too  large  
§  Possibly  round  to  fit  into  frac

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   23

 Carnegie Mellon

Rounding  
¢  Rounding  Modes  (illustrate  with  $  rounding)  

¢    $1.40  $1.60  $1.50  $2.50  –$1.50  

§  Towards  zero  $1  $1  $1  $2  –$1  
§  Round  down  (−∞)  $1  $1  $1  $2  –$2  
§  Round  up  (+∞)    $2  $2  $2  $3  –$1  
§  Nearest  Even  (default)  $1  $2  $2  $2  –$2  

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   24

 Carnegie Mellon

Closer  Look  at  Round-­‐To-­‐Even  

¢  Default  Rounding  Mode  
§  Hard  to  get  any  other  kind  without  dropping  into  assembly  
§  All  others  are  sta;s;cally  biased  
§  Sum  of  set  of  posi;ve  numbers  will  consistently  be  over-­‐  or  under-­‐  
es;mated  

¢  Applying  to  Other  Decimal  Places  /  Bit  Posi;ons  

§  When  exactly  halfway  between  two  possible  values  
Round  so  that  least  significant  digit  is  even  
§ 
§  E.g.,  round  to  nearest  hundredth  
 7.8949999  7.89  (Less  than  half  way)  
 7.8950001  7.90  (Greater  than  half  way)  
 7.8950000  7.90  (Half  way—round  up)  
 7.8850000  7.88  (Half  way—round  down)  
Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   25

 Carnegie Mellon

Rounding  Binary  Numbers  

¢  Binary  Frac;onal  Numbers  
§  “Even”  when  least  significant  bit  is  0
§  “Half  way”  when  bits  to  right  of  rounding  posi;on  =  100…2

¢  Examples  
§  Round  to  nearest  1/4  (2  bits  right  of  binary  point)  
Value  Binary  Rounded  Ac;on  Rounded  Value  
2  3/32  10.000112  10.002  (<1/2—down)  2  
2  3/16  10.001102  10.012  (>1/2—up)  2  1/4  
2  7/8  10.111002  11.002  (    1/2—up)  3  
2  5/8  10.101002  10.102  (    1/2—down)  2  1/2  

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   26

 Carnegie Mellon

FP  Mul.plica.on  
¢  (–1)s1  M1    2E1      x      (–1)s2  M2    2E2  
¢  Exact  Result:  (–1)  M    2  
s E

§  Sign  s:      s1  ^  s2  

§  Significand  M:    M1  x    M2  
§  Exponent  E:    E1  +  E2  

¢  Fixing  
§  If  M  ≥  2,  shi`  M  right,  increment  E  
§  If  E  out  of  range,  overflow    
§  Round  M  to  fit  frac  precision  

¢  Implementa;on  
§  Biggest  chore  is  mul;plying  significands  
Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   27

 Carnegie Mellon

Floa.ng  Point  Addi.on  

¢  (–1)s1  M1    2E1      +      (-­‐1)s2  M2    2E2   Get binary points lined up

§ Assume  E1  >  E2  
E1–E2

s E (–1)s1  M1    
¢  Exact  Result:  (–1)  M    2  

§ Sign  s,  significand  M:     +   (–1)s2  M2    

Result  of  signed  align  &  add  
§ 
§ Exponent  E:    E1   (–1)s  M  

¢  Fixing  
§ If  M  ≥  2,  shi`  M  right,  increment  E    
§ if  M  <  1,  shi`  M  le`  k  posi;ons,  decrement  E  by  k  
§ Overflow  if  E  out  of  range  
§ Round  M  to  fit  frac  precision  
Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   28

 Carnegie Mellon

Mathema.cal  Proper.es  of  FP  Add  

¢  Compare  to  those  of  Abelian  Group  
§  Closed  under  addi;on?     Yes      
§  But  may  generate  infinity  or  NaN  
§  Commuta;ve?     Yes  
§  Associa;ve?   No  
§  Overflow  and  inexactness  of  rounding  
§  (3.14+1e10)-1e10 = 0, 3.14+(1e10-1e10) = 3.14
§  0  is  addi;ve  iden;ty?    
§  Every  element  has  addi;ve  inverse?   Yes  
§  Yes,  except  for  infini;es  &  NaNs   Almost  
¢  Monotonicity  
§  a  ≥  b    a+c  ≥  b+c?   Almost  
§  Except  for  infini;es  &  NaNs  

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   29

 Carnegie Mellon

Mathema.cal  Proper.es  of  FP  Mult  

¢  Compare  to  Commuta;ve  Ring  
§  Closed  under  mul;plica;on?   Yes  
But  may  generate  infinity  or  NaN  
§ 
§  Mul;plica;on  Commuta;ve?   Yes  
§  Mul;plica;on  is  Associa;ve?   No  
§  Possibility  of  overflow,  inexactness  of  rounding  
§  Ex:  (1e20*1e20)*1e-20=  inf,  1e20*(1e20*1e-20)=  1e20
§  1  is  mul;plica;ve  iden;ty?   Yes  
§  Mul;plica;on  distributes  over  addi;on?   No  
§  Possibility  of  overflow,  inexactness  of  rounding  
§  1e20*(1e20-1e20)=  0.0,    1e20*1e20 – 1e20*1e20 =  NaN

¢  Monotonicity  
§  a  ≥  b    &  c  ≥  0      a  *  c  ≥  b  *c?   Almost  
§  Except  for  infini;es  &  NaNs  
Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   30

 Carnegie Mellon

Today:  Floa.ng  Point  

¢  Background:  Frac;onal  binary  numbers  
¢  IEEE  floa;ng  point  standard:  Defini;on  

¢  Example  and  proper;es  

¢  Rounding,  addi;on,  mul;plica;on  

¢  Floa;ng  point  in  C  

¢  Summary  

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   31

 Carnegie Mellon

Floa.ng  Point  in  C  

¢  C  Guarantees  Two  Levels  
§ float  single  precision  
§ double  double  precision  

¢  Conversions/Cas;ng  
§   Cas;ng  between  int,  float,  and  double  changes  bit  representa;on  
§   double/float  →  int  
§  Truncates  frac;onal  part  
§  Like  rounding  toward  zero  
§  Not  defined  when  out  of  range  or  NaN:  Generally  sets  to  TMin  
§   int  →  double  
§  Exact  conversion,  as  long  as  int  has  ≤  53  bit  word  size  
§   int  →  float  
§  Will  round  according  to  rounding  mode  

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   32

 Carnegie Mellon

Floa.ng  Point  Puzzles  

¢  For  each  of  the  following  C  expressions,  either:  
§  Argue  that  it  is  true  for  all  argument  values  
§  Explain  why  not  true  
•  x == (int)(float) x
•  x == (int)(double) x
•  f == (float)(double) f
int x = …;
•  d == (double)(float) d
float f = …;
double d = …; •  f == -(-f);
•  2/3 == 2/3.0
Assume  neither •  d < 0.0 ((d*2) < 0.0)
d  nor  f  is  NaN   •  d > f -f > -d
•  d * d >= 0.0
•  (d+f)-d == f

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   33

 Carnegie Mellon

Summary  
¢  IEEE  Floa;ng  Point  has  clear  mathema;cal    proper;es  
E
¢  Represents  numbers  of  form  M  x  2  

¢  One  can  reason  about  opera;ons  independent  of  

implementa;on  
§  As  if  computed  with  perfect  precision  and  then  rounded  
¢  Not  the  same  as  real  arithme;c  
§  Violates  associa;vity/distribu;vity  
§  Makes  life  difficult  for  compilers  &  serious  numerical  applica;ons  
programmers  

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   34

 Carnegie Mellon

Addi.onal  Slides  

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   35

 Carnegie Mellon

Crea.ng  Floa.ng  Point  Number  

¢  Steps   s   exp   frac  
§  Normalize  to  have  leading  1  
1   4-­‐bits   3-­‐bits  
§  Round  to  fit  within  frac;on  
§  Postnormalize  to  deal  with  effects  of  rounding  

¢  Case  Study  

§  Convert  8-­‐bit  unsigned  numbers  to  ;ny  floa;ng  point  format  
Example  Numbers  
128 10000000
15 00001101
33 00010001
35 00010011
138 10001010
63 00111111
Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   36

 Carnegie Mellon

Normalize   s   exp   frac  

1   4-­‐bits   3-­‐bits  
¢  Requirement  
§  Set  binary  point  so  that  numbers  of  form  1.xxxxx  
§  Adjust  all  to  have  leading  one  
Decrement  exponent  as  shi`  le`  
§ 
Value  Binary  Frac;on  Exponent  
128 10000000 1.0000000 7
15 00001101 1.1010000 3
17 00010001 1.0001000 4
19 00010011 1.0011000 4
138 10001010 1.0001010 7
63 00111111 1.1111100 5

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   37

 Carnegie Mellon

Rounding   1.BBGRXXX
Guard  bit:  LSB  of  result  
S;cky  bit:  OR  of  remaining  bits  
Round  bit:  1st  bit  removed  

¢  Round  up  condi;ons  

§  Round  =  1,  S;cky  =  1  ➙  >  0.5  
§  Guard  =  1,  Round  =  1,  S;cky  =  0  ➙  Round  to  even  
Value  Frac;on  GRS  Incr?  Rounded  
128 1.0000000 000 N 1.000
15 1.1010000 100 N 1.101
17 1.0001000 010 N 1.000
19 1.0011000 110 Y 1.010
138 1.0001010 011 Y 1.001
63 1.1111100 111 Y 10.000

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   38

 Carnegie Mellon

Postnormalize  
¢  Issue  
§  Rounding  may  have  caused  overflow  
§  Handle  by  shi`ing  right  once  &  incremen;ng  exponent  
Value  Rounded  Exp  Adjusted  Result  
128 1.000 7 128
15 1.101 3 15
17 1.000 4 16
19 1.010 4 20
138 1.001 7 134
63 10.000 5 1.000/6 64

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   39

 Carnegie Mellon

Interes.ng  Numbers   {single,double}  

Descrip/on  exp  frac  Numeric  Value  
¢  Zero  00…00  00…00  0.0  
¢  Smallest  Pos.  Denorm.  00…00  00…01  2–  {23,52}  x  2–  {126,1022}  
§  Single  ≈  1.4  x  10–45  
§  Double  ≈  4.9  x  10–324  
¢  Largest  Denormalized  00…00  11…11  (1.0  –  ε)  x  2–  {126,1022}  
§  Single  ≈  1.18  x  10–38  
§  Double  ≈  2.2  x  10–308  
¢  Smallest  Pos.  Normalized  00…01  00…00  1.0  x  2–  {126,1022}  
§  Just  larger  than  largest  denormalized  
¢  One  01…11  00…00  1.0  
¢   Largest  Normalized  11…10  11…11  (2.0  –  ε)  x  2{127,1023}  
§  Single  ≈  3.4  x  1038  
§  Double  ≈  1.8  x  10308  

Bryant  and  O’Hallaron,  Computer  Systems:  A  Programmer’s  Perspec;ve,  Third  Edi;on   40