Floating Point Round to Even (using bitwise operations only)

/* 
 * CS:APP Data Lab 
 * 
 * fp-add.c - Source file for the floating-point rounding Lab.
 *            You will hand in "fp-round.c"
 */
 
#if 0
/*
 * Read the following instructions carefully.
 */
 
You will provide your solution to this lab by editing the file "fp-round.c".
 
  Each "Expr" is an expression using ONLY the following:
  1. Integer constants 0 through 255 (0xFF), inclusive. You are
      not allowed to use big constants such as 0xffffffff.
  2. Function arguments and local variables (no global variables).
  3. Unary integer operations ! ~
  4. Binary integer operations & ^ | + << >>
    
  Some of the problems restrict the set of allowed operators even further.
  Each "Expr" may consist of multiple operators. You are not restricted to
  one operator per line.
 
  You are expressly forbidden to:
  1. Use any control constructs such as do, while, for, switch, etc.
  2. Define or use any macros.
  3. Define any additional functions in this file.
  4. Call any functions.
  5. Use any other operations, such as &&, ||, -, or ?:
  6. Use any form of casting.
 
  However, you may use one-level-deep IF statements.  That is, you
  may write
 
  if( test ) {
    varQ = ExprQ;
    varR = ExprR;
    ...
  }
 
  You may assume that your machine:
  1. Uses 2s complement, 32-bit representations of integers.
  2. Performs right shifts arithmetically.
  3. Has unpredictable behavior when shifting an integer by more
     than the word size.
#endif
 
#include "fp.h"
int print_flg = 0;
 
 
i32 fp_add( i32 x, i32 y )
{
  i32 t;
 
  // Set X to be input with equal or larger exponent.
  if ( f32_exp(x) < f32_exp(y) ) {t = y; y = x; x = t;}
 
  i32 x_exp = f32_exp(x);
  i32 y_exp = f32_exp(y);
 
  i32 x_dnrm = ! x_exp;
  i32 y_dnrm = ! y_exp;
 
  i32 ans_exp = x_exp;
 
  if ( x_dnrm ) x_exp = 1;
  if ( y_dnrm ) y_exp = 1;
 
  i32 exp_diff = x_exp - y_exp;
 
  i32 x_sgn = f32_sgn(x);
  i32 x_man = f32_man(x);
  if ( !x_dnrm ) {x_man |= (1 << 23);}
 
  i32 y_sgn = f32_sgn(y);
  i32 y_man = f32_man(y);
  if ( !y_dnrm ) {y_man |= (1 << 23);}
 
  // Example debugging statements...
  if ( print_flg ) {
    printf( "x_sgn:  %d, x_dnrm: %d, x_exp:  %02x, x_man: 0x:%08x\n",
	    x_sgn, x_dnrm, x_exp, x_man );
    printf( "y_sgn:  %d, y_dnrm: %d, y_exp:  %02x, y_man: 0x:%08x\n",
	    y_sgn, y_dnrm, y_exp, y_man );
    }
 
  exp_diff = ( exp_diff > 26 ) ? 26 : exp_diff;
  i32 ans_sgn = x_sgn;  // Just positive numbers.
  i32 ans_man = x_man + ( y_man >> exp_diff );
  i32 ans_rnd = y_man & (~(-1 << exp_diff));
 
  // Put your round-to-even solution in the file "round.c".
  // The contents of the file "fp-round.c" will be inserted
  // here by the "#include" directive.
 
#include "fp-round.c"
 
  i32 ans_all = f32_sem( ans_sgn, ans_exp, ans_man );
  return( ans_all );
}  
 
 
i32 main (int argc, char *argv[], char *env[] )
{
  if32 a, b, f_ans, i_ans;
  i32 i;
  i32 correct_count = 0;
  i32 incorrect_count = 0;
 
  i32 number_of_tests = 100;  // Number of test cases to try.
 
  for( i = 0; i < number_of_tests; i++ )
    {
      print_flg = 0;
 
      // Generate suitable test inputs
      do{ a.ival = random(); }
      while( f32_exp(a.ival) == 255);
      do{ b.ival = random(); }
      while( f32_exp(b.ival) == 255);
 
      // Perform the addition, using our integer-based solution.
      i_ans.ival = fp_add( a.ival, b.ival );
 
      // Perform the addition, using the floating-point add instruction.
      f_ans.fval = a.fval + b.fval;
 
      // If different, rerun with the print_flg set so debugging messages
      // can be observed.
 
      if ( i_ans.ival != f_ans.ival )
	{
	  incorrect_count++;
	  print_flg = 1;
	  fp_add( a.ival, b.ival );
 
	  printf( "i: %5d, ", i );
	  printf( "a: 0x:%08x, b: 0x:%08x, i_ans: 0x:%08x, f_ans: 0x:%08x.\n\n",
		  a.ival, b.ival, i_ans.ival, f_ans.ival);
          print_flg = 0;
	}
      else
	correct_count++;
 
    }
 
  printf( "tests correct: %d\n", correct_count);
  printf( "tests incorrect: %d\n", incorrect_count );
 
  return( !!incorrect_count );
 
}