VHDL implementation details for modified non restoring square root algorithm shifting

Hi,

I found this pdf (link below) which shows the algorithm for the square root, but I couldn't understand it properly. Can any one help? I want to write a VHDL code for it. Shifting part in it is confusing.

"Link...(PDF link)":http://telkomnika.ee.uad.ac.id/n9/files/Vol.8No.1Apr10/8.1.4.10.01.pdf

Here's a step-by-step binary algorithm I adapted from the by-hand method for decimal numbers. It is followed by some regrettably over-terse C code that implements it. These are taken from an article I wrote:
www.genapro.com/techbd.htm
most of which you can (and probably should) ignore, but at the very bottom are some further notes about the algorithm, including generating a fractional remainder (since most roots don't turn out to be nice whole integers).


[code lang="c" line="none"]
Use 5 registers:
argu_reg = input argument register
test_reg = bits get shifted in from argu_reg in pairs
work_reg = "working" reg; is subtracted from test_reg
subt_reg = test_reg - work_reg is stored here
rslt_reg = square root result register
Clear regs then load value to be rooted in argu_reg

The algorithm (all shifts are to the left unless otherwise noted):
shift the 2 MSBs of argu_reg into test_reg LSBs
shift a One into work_reg LSB
subtract work_reg from test_reg and store in subt_reg
algorithm test point: did subtraction yield a non-negative value?
yes
add One to work_reg
shift One into rslt_reg
copy subt_reg into test_reg
no
subtract One from work_reg
shift Zero into rslt_reg
Continue algorithm
[/code]


[code lang="c" line="none"]
void
ComputeIntegerSquareRoot (
short arga, /* input argument register */
short *root)
{
short mina;
short j, k;
short bit = 0x8000;
short tsta = 0; /* bits get shifted in from arga in pairs */
short wrka = 0; /* "working" reg; is subtracted from tsta */
short rslt = 0; /* square root result reg */
short cntn = 0; /* clock count nibble */

/* all shifts are to the left */
do{
/* two new bits get shifted in from arga to tsta */
for (k = 0; k < 2; k++)
{
cntn += 1;
arga

I dont' know what you will be using the square root function for, but in many cases when there's a limited amount of different numbers you need the square root of, a simple lookup table will do the job at lightning speed. Used that quite a bit for graphics calculations.

#define max_sq 255
int sq[max_sq]={0, 1, 1, 1, 2, 2, 2, 2, 2, 3............ etc. }


when needing the square root of x just use:
sq[x]

(but make sure the table is always long enough)

Thank you.


Thought of almost same thing, I think it will work.

I am using it for 48 bits, so look up table will be costly.