CS 2734 Laboratory 1

CS 2734 Computer Organization II -- Spring 2001
Laboratory 3 [Jan 29, 31]: Floating Point Number Formats
(`double` in the IEEE standard)

For this laboratory, you are to experiment with the bit pattern used to represent a double by computers that adhere to the IEEE standard for doubles. (See text, Section 4.8, pages 275-280. Sun hardware follows the standard.)

Given either an "ordinary" floating point number or a bit pattern, it is easy to get the other representation, say, with a simple program like the following:

four06% cat floats.c
/* floats.c: show bit representation for doubles */
#include <stdio.h>
#include <ctype.h>
void main(void){
   union {
      double d; 
      struct {
         int p;
         int q;
      } b;   
   } r;
   char ch;
   for( ; ; ) {
      while (isspace(ch = getchar()))
         ;
      if (ch == 'x') {
         scanf("%x %x", &r.b.p, &r.b.q);
         printf("  Decimal: %20.16e\n", 
            r.d);
         printf("  Bits: %08x %08x\n",
            r.b.p, r.b.q);
      }
      else if (ch == 'f') {
         scanf("%lf", &r.d);
         printf("  Decimal: %20.16e\n",
            r.d);
         printf("  Bits: %08x %08x\n",
            r.b.p, r.b.q);
      }
      else break;
   }
}

Typical output looks like:

f -0.75
  Decimal: -7.5000000000000000e-01
  Bits: bfe80000 00000000
f 16.0
  Decimal: 1.6000000000000000e+01
  Bits: 40300000 00000000
f .75
  Decimal: 7.5000000000000000e-01
  Bits: 3fe80000 00000000
f 1.5
  Decimal: 1.5000000000000000e+00
  Bits: 3ff80000 00000000
x 3fe80000 00000000
  Decimal: 7.5000000000000000e-01
  Bits: 3fe80000 00000000
x bfffffff ffffffff
  Decimal: -1.9999999999999998e+00
  Bits: bfffffff ffffffff

For the actual laboratory work:

Create a new directory for this assignment.
Copy, compile, and run the C program above. Try out some of the simple inputs shown.
Complete the four items below.
1. Check out the number -0.75 above. Convince yourself that you agree with the text, page 279. (Convert the hex numbers to binary by hand and see that your fields agree with those in the text.)
2. Determine the bits for the numbers -1.0, -2.0, -4.0, and -8.0. Give an explanation for them. (In each case, determine the different floating point fields and see that you really have a representation for the number shown.)
3. Determine the bits for the number -6.25, and give a careful explanation for them. (Again, determine the fields, and verify that this bit pattern really does represent the number -6.25.)
4. Determine the bits for the number 0.1, that is, the number 1/10. Are you surprised? Again, give a careful explanation. (This is quite a bit more challenging to do. For a really good answer, you would have to use formulas for geometric series that you may have learned in college algebra.)
Show your answers and results to the lab TA for checkout.

Extra for those bored with the above:
Here is a more interesting program that tears an input double apart and assembles the individual pieces as in the book:

four06% cat floating.c
/* floating.c: input a double, tear it into its component, reassemble.
 *   See Patterson & Hennessy, Comp. Org. & Design, pages 278-279
 *   for notation.
 *   Here Result = (-1)^Sign x (1 + Significand) x 2^(Exponent - Bias)
 */
#include <stdio.h>
#include <ctype.h>
/* this union allows one to extract bits from a double */
union double_tag{
   double d; 
   struct {
      unsigned int p;
      unsigned int q;
   } b;   
};
void main(void){
   union double_tag r; /* holds the input */
   unsigned int Sign_mask        = 0xA0000000; /* to extract Sign */
   unsigned int Exponent_mask    = 0x7FF00000; /* to extract Exponent */
   unsigned int Signific_mask = 0x000FFFFF; /* to extract Signficand */
   unsigned int Sign; /* the Sign */
   unsigned int Exponent; /* the Exponent */
   unsigned int Signific; /* the Signicand, as an integer */
   double Significand; /* the Significand */
   unsigned int Bias = 1023; /* the Bias */
   double Result; /* the result of reassembling */
   int BiasedExponent; /* the Biased Exponent == Exponent - Bias */
   int i;
   for( ; ; ) {
      scanf("%lf", &r.d);
      Sign = (r.b.p & Sign_mask) >> 31;
      Exponent = (r.b.p & Exponent_mask) >> 20;
      Signific  = r.b.p & Signific_mask;
      Significand = ( (double) Signific + r.b.q / 4294967295.0) / 1048576.0;
      /* Note: the extra r.b.q / 4294967295.0 adds in the lower 32 bits. */
      printf("(-1)^Sign x (1 + Significand) x 2^(Exponent - Bias) = Result\n");
      Result = (Sign ? -1.0 : 1.0) * (1 + Significand);
      BiasedExponent = Exponent - Bias;
      if (BiasedExponent >= 0) {
          for (i = 0; i < BiasedExponent; i++)
             Result = Result * 2.0;
      }
      else {
          for (i = 0; i < -BiasedExponent; i++)
             Result = Result / 2.0;
      }
      printf("(-1)^%1i    x (1 + %11.9f) x 2^(%4i     - %4i) = %20.16f\n",
          Sign, Significand, Exponent, Bias, Result);
   }
}

Output looks like:

four06% cc -o floating floating.c
four06% floating
-0.75
(-1)^Sign x (1 + Significand) x 2^(Exponent - Bias) = Result
(-1)^1    x (1 + 0.500000000) x 2^(1022     - 1023) =  -0.7500000000000000
16.0
(-1)^Sign x (1 + Significand) x 2^(Exponent - Bias) = Result
(-1)^0    x (1 + 0.000000000) x 2^(1027     - 1023) =  16.0000000000000000
.75
(-1)^Sign x (1 + Significand) x 2^(Exponent - Bias) = Result
(-1)^0    x (1 + 0.500000000) x 2^(1022     - 1023) =   0.7500000000000000
1.5
(-1)^Sign x (1 + Significand) x 2^(Exponent - Bias) = Result
(-1)^0    x (1 + 0.500000000) x 2^(1023     - 1023) =   1.5000000000000000
-2.0
(-1)^Sign x (1 + Significand) x 2^(Exponent - Bias) = Result
(-1)^1    x (1 + 0.000000000) x 2^(1024     - 1023) =  -2.0000000000000000
ctrl-C

Revision date: 2001-01-23. (Please use ISO 8601, the International Standard.)

CS 2734 Computer Organization II -- Spring 2001 Laboratory 3 [Jan 29, 31]: Floating Point Number Formats (double in the IEEE standard)

CS 2734 Computer Organization II -- Spring 2001
Laboratory 3 [Jan 29, 31]: Floating Point Number Formats
(`double` in the IEEE standard)