Non-restoring Floating Point Square Root Algorithm - c++

Question

I am trying to use the non-restoring algorithm for computing the square root of a floating point number.
For instance, say x = 1001, the square root is 31.6386
I want to calculate this square root using the non-restoring method.
I tried following the method in the paper:
Implementation of Single Precision Floating Point Square Root on FPGAs
but it appears my result is slightly off by 1 bit. I'm not able to figure out why though.
For instance, the program I wrote below will produce the following results:
correct_result =
41FD1BD2
myresult =
41FD1BD1
error =
1.192093e-007
C++ version of the code :
#include <iostream>
#include <cmath>
using namespace std;
union newfloat{
float f;
int i;
};
int main () {
// Input number
newfloat x;
cout << "Enter Number: ";
cin >> x.f;
// Pull out exponent and mantissa
int exponent = (x.i >> 23) & 0xFF;
int mantissa = (x.i & 0x7FFFFF) | ((exponent && exponent) << 23);
// Calculate new exponent
int new_exponent = (exponent >> 1) + 63 + (exponent & 1);
// Shift right (paper says shift left but shift left doesn't work?)
if (exponent & 1) {
mantissa = mantissa >> 1;
cout << " Shifted right " << endl;
}
// Create an array with the bits of the mantissa
unsigned int D [48];
for (int i = 47; i >= 0; i--) {
if (i >= 24) {
D[i] = (mantissa >> (i-24)) & 1;
} else {
D[i] = 0;
}
}
// == Perform square root ==
// Set q24 = 0, r24 = 0 and then iterate from k = 23 to 0
int q[25] = {0}; // 25 element array, indexing ends at 24
int r[25] = {0};
for (int k = 23; k >= 0; k--) {
if (r[k+1] >= 0) {
r[k] = ((r[k+1] << 2) | (D[2*k+1] << 1) | D[2*k] ) - (q[k+1] << 2 | 1 );
} else {
r[k] = ((r[k+1] << 2) | (D[2*k+1] << 1) | D[2*k] ) + (q[k+1] << 2 | 0x3 );
}
if (r[k] >= 0) {
q[k] = (q[k+1] << 1) | 1;
} else {
q[k] = q[k+1] << 1;
}
if (k == 0) {
if (r[0] < 0) {
r[0] = r[0] + (q[0] << 1) | 1;
}
}
}
// Create quotient from LSBs of q[]
int Q = 0;
for (int i = 0; i <= 23; i++) {
Q = Q | ((q[i] & 1) << i);
}
// Option 1 Rounding
//if (r[0] > 0) // Works for 10, 1001, 1021, but not 1012
// Q = Q + 1;
// Option 2 Rounding (No rounding)
// Works for 1012, Doesn't work for 10, 1001, 1021
// Option 3 Rounding (Calculate the next 3 Quotient bits to get a guard round and sticky bit)
// Calculate correct result:
newfloat correct_result;
correct_result.f = sqrt(x.f);
// Form my result into a single number
newfloat myresult;
myresult.i = (new_exponent << 23) | (Q & 0x7FFFFF);
// Print results
cout << hex << "My result: " << myresult.i << endl;
cout << hex << "Correct: " << correct_result.i << endl;
return 0;
}

Answer 1

First let me highlight the relevant part from the paper:
You need to take another look at how the additions/subtractions are done. You code is performing it in regular double-numbers, but I think the algorithm is designed with integer modular arithmetic in mind.
So if you look at the example listed later in the paper, the computation of 0011 - 0101 wraps around to give 1110.
That could explain why you're getting the wrong results, I think :)

Answer 2

I was looking through the c++ version of your program and reading that document today. It seems to me that the algorithm is intended to provide both a quotient and a remainder. As in the example provided, he uses his algorithm to get the square root of 127, to which it provides a result of 11 + R 6. 112 + 6 = 127.
That was with an integer, but every data type has a limit to its precision. This leads me to believe that your program is executing as expected, its just that you've run out of precision, at least for the way the square root is being calculated, and for the data type being used. I expect you would find your minute "lost" precision in r[0].
I saw from the comments in the code that you intended to, or tried to calculate out extra precision. That seems like a reasonable path to try. Do note that, in addition to the other changes that would be required to do this, you would have to take out (or move) the check k == 0; since it modifies the remainder, which would mess up the loop.
I think the real question is what size precision is acceptable to you. For instance, the c++ sqrt function (and yours) are off by 0.00000002 on sqrt(2). No one seems to mind. Considering the program you wrote is off from the c++ sqrt function by less than that in the instances where it doesn't match. I spent the majority of the day breaking it down, testing the individual parts, and reviewing the subject matter, and couldn't find anything blatantly wrong. It seem close enough for government work to me.