Thread: square root algorithm???

LuckY nailed this one. It was less code than I thought there would be. What would I need to learn to make it graphical? Like have a square calculator pop up when I run the .exe file with buttons for each number a a screen that displays what you are entering. Basically just like the windows calculator. Would that deal with OpenGL or what?

There are many options for making it graphical. You could go with poratble solutions like OpenGl, SDL, Allegro, wxWindows,... or if your working in windows use win32 API. But first I would make sure I have a functional program then worring about adding a gui.

From the laws on indices, the square root of a number is that number to the power of a half, so, what is wrong with this code, because for some reason, the answer is always 2, it might be the ^, I think that is the power operator, from what is happening, I think it might mean something different...

Code:

int x;
    int funct;
    funct = x^(1/2);
    cout << "Please input a number:" << endl;
    cin >> x;
    cout << funct << endl;

^ is not the power operator, it is the bitwise exclusive or operator.

Besides, you never initialize x before using it so it wouldn't work anyway.

The ^ is not the power operator it's the bitwise OR.

Power function is like so: double pow(double x, double y);

But I think this takes the fun out of it so to speak. Here is another method although it is more convoluted than the previous example given by Sang-drax .

I actually also implemented that algorithm. I have found, however, that it is not very accurate beyond 5 decimal digits. After that things go downhill and fast.

You don't have to iterate Newton's algoritm 100 times.

When the algorithm converges (it always does in this case), it does so quadratically = quite fast.

Try around 10 iterations. This is just a suggestion, I don't know if speed matters to you.

always a fun time:

Code:

std::complex<double> mysqrt(double num, const double precision = 0.0000001);
std::complex<double> mysqrt(double num, const double precision )
{
  bool real = true;

  if ( num < 0.0 )
  {
    real = false;
    num = -num;
  }

  double root = 1.0;
  while ( fabs((root * root) - num) > precision )
    root = (root + (num/root)) / 2;

  if ( real )
    return std::complex<double>(root,0);
  return std::complex<double>(0,root);

}

Edit: Credit to LuckY for the

Code:

root = (root + (num/root)) / 2;

Excellent explanation Micko.

This is just another implementation of the newtonian approximation algorithm. I wrote this as a part of my math library. It works, but it's not really faster than crt sqrt much less the sqrt method on your floating point unit (you can't realistically beat hardware). If you need to also balance speed you can actually download the doom3 sdk as I believe it contains methods for using the approximation algorithm with a clever way of finding the seed (initial guess)...this is used in the lighting algorithms.

so, here's my implementation:

float IterSqrtf(float r, int numtries)
{
float m(0.0f);
float b(0.0f);
float currx=r;
float curry(0.0f);
float root(0.0f); //this is what gets returned

while(numtries--)
{
curry = (currx*currx) - r; //y1
//Check to see if curry is < 0
m = 2 * currx;
b = (-m*currx) + curry;
root = -b / m;
currx = root;
}
return root;
}

Here's an implementation from tricks of the 3d game programming gurus...it's faster than sqrt() and is always within 5% accuracy

float Faster_Sqrtf(float f)
{
float result;

_asm
{
mov eax, f
sub eax, 0x3f800000
sar eax, 1
add eax, 0x3f800000
mov result, eax
}

return result;
}

Originally Posted by pktcperlc++java

the way I did this for my own calculator was through a for loop

Code:

for(int i=0;pow(i,2)<number;i+=0.001){

//do nothing inside loop

}//end for

the +=0.001 ends up being formated by the compiler as a huge string of decimals and it can always be formated later in the code

a bit off topic:
this
for(int i=0;pow(i,2)<number;i+=0.001);
works without the {} and is more readable