I'm having trouble with Floating Point Addition in C.
We're given two 16 bit numbers, we're supposed to add them not worrying about cases where their signs are different or where the exponents are 0 or 31.
This is a homework assignment, but I'm late & I can't figure out why it's not working.
The Algrothim sort of looks like:
- Get the sign bits of each number, if their different return 0.
- Get the exponents of each number, find the bigger one 2a. find out the difference between the two.
- in the 11th bit put in a implicit one into each of the mantissa's
- Right shift the number with the smaller exponent by the difference of the exponents
- Take the sign and exponent of the larger number or it with the shifted mantissa.
- Return the result.
Here's my code:
LC3_Word FLADD(LC3_Word A, LC3_Word B)
{
// a debug variable, so we can turn errors on (debug = 1) and off (debug = 0)
int debug = 1;
// a default return value
LC3_Word returnValue = 0x0000;
if(debug)
{
printf("-----------------------------------\nBegin debug\n-----------------------------------\n");
printf("Return value: %x \n",returnValue);
printf("LC3 words: A %x, B %x\n",A,B);
}
// Masks to extract sign, exponent and fraction
LC3_Word signBitMask = 0x8000;
LC3_Word expMask = 0x7C000;
LC3_Word mantissaMask = 0x03FF;
// Mask to get the sign with the exponent
LC3_Word signExpMask = 0xFC00;
// A mask for the implicit 1
LC3_Word implicitOne = 0x0400;
// Getting the signs
LC3_Word signA = AND(signBitMask,A);
LC3_Word signB = AND(signBitMask,B);
// Getting the exponents
LC3_Word expA = AND(expMask,A);
LC3_Word expB = AND(expMask,B);
// Getting the mantissa's
LC3_Word mantA = AND(mantissaMask,A);
LC3_Word mantB = AND(mantissaMask,B);
if(debug)
{
printf("======================\n");
printf("\tSignBitMask: %x\n\texpMask: %x\n\tmantissaMask: %x\n",signBitMask,expMask,mantissaMask);
printf("\tSign EXP Mask: %x\n",signExpMask);
printf("\tsignA: %x, signB: %x\n", signA, signB);
printf("\tImplicit One Mask: %x\n",implicitOne);
printf("\tExp of a: %x, Exp of b: %x\n", expA, expB);
printf("\tmantissa of A: %x,mantissa of B: %x\n",mantA,mantB);
printf("======================\n");
}
// Getting each with it's sign bit and it's exponent
LC3_Word signExpA = AND(signExpMask,A);
LC3_Word signExpB = AND(signExpMask,B);
if(debug)
{
printf("signExpA of A: %i, signExpB of B: %i\n",signExpA,signExpB);
}
// if the signs are different, don't deal with this case
if(signA!=signB)
{
return 0;
}
// if the signs are the same, if not, just return the default value
if(signA==signB)
{
if(debug)
{
printf("We got into the if signs are the same block \n");
printf("Sign a: %i, Sign b: %i \n",signA,signB);
}
if(expA==expB)
{
if(debug)
{
printf("We got into the if exponents are the same block \n");
printf("Exp a: %x, Exp b: %x \n",expA,expB);
}
// exponents are the same
// Add Mantissa B to A
mantA = ADD(mantB,mantA);
if(debug)
{
printf("Addition of mantissa's %x\n",mantA);
}
// store into the return value the logical and of the mantissa with the existing exponent and sign
// might want to do an OR() not an AND()
returnValue = OR(signExpA,mantA);
} // end if the eponents are the same
else {
if(debug)
{
printf("The exponents are not the same block \n");
}
// Getting the size we need to shift by
int sizeToShift = 0;
if(expA>expB)
{
// Mask the mantissa of B with a implicit 1, then right shift
mantB = OR(implicitOne,mantB);
if(debug)
{
printf("The exponent a is > b\n");
}
// need to shift B, getting the size of how much
sizeToShift = expA-expB;
if(debug)
{
printf("size to shift: %d,\nmantissaB is: %x\n",sizeToShift,mantB);
}
// right shifting the mantissa of b
mantB = mantB >> sizeToShift;
if(debug)
{
printf("mantissa of b shifted: %x\n",mantB);
}
returnValue = OR(signExpA,ADD(mantA,mantB));
}// end if A > B in the exponent
else
{
// Mask the mantissa of A with a implicit 1, then right shift
mantA = OR(implicitOne,mantA);
if(debug)
{
printf("The exponent B is > A\n");
}
// need to shift A, getting the size of how much
sizeToShift = expB-expA;
if(debug)
{
printf("size to shift: %d,\nmantissaA is: %x\n",sizeToShift,mantA);
}
// right shifting the mantissa of A
mantA = mantA >> sizeToShift;
if(debug)
{
printf("mantissa of A shifted: %x\n",mantA);
}
returnValue = OR(signExpB,ADD(mantA,mantB));
}// end if B > A in the exponent
}// end if different exponents
} // end if the signs are the same
if(debug)
{
printf("Return Value %x\n",returnValue);
printf("-----------------------------------\nEnd debug\n-----------------------------------\n");
}
return returnValue;
}
Here are ADD, OR and AND,
LC3_Word AND(LC3_Word A, LC3_Word B)
{
return (A&B);
}
LC3_Word OR(LC3_Word A, LC3_Word B)
{
return (A|B);
}
LC3_Word ADD(LC3_Word A, LC3_Word B)
{
return (A+B);
}
When I add 2 + 3 in floating point I get 3 instead of 5.
Any ideas?
#defineand#ifdefinstead, they will be managed by preprocessor and strip out if needed as they've never existed in code - phuclv