计算平方根的算法

申明，本文非笔者原创，原文转载自：http://www.cnblogs.com/xkfz007/archive/2012/05/15/2502348.html

总结一下一些常用的计算平方根的方法

1.  牛顿法

具体的做法如下： 

 计算公式如下： 

具体的计算程序如下： 

double sqrt_( double x)         
{
     double g=x;
     while(ABS(g*g-x)> 0.000001)
    {
        g=(g+x/g)/ 2;
    }
     return g;
}

2. 利用级数进行逼近

 微积分中的泰勒级数如下：

 

这样，有了这个公式我们可以得到求平方根公式的展开式：

  这样我们可以进行在一定精度内的逼近。

但是这儿存在一个问题，就是这个公式的收敛问题。它是存在收敛区间的。  

 所以可以得到最后的代码：

double Tsqrt( double x) // 计算[0,2)范围内数的平方根
{
     double sum,coffe,factorial,xpower,term;
     int i;
    sum= 0;
    coffe= 1;
    factorial= 1;
    xpower= 1;
    term= 1;
    i= 0;
     while(ABS(term)> 0.000001)
    {
        sum+=term;
        coffe*=( 0.5-i);
        factorial*=(i+ 1);
        xpower*=(x- 1);
        term=coffe*xpower/factorial;
        i++;
    }
     return sum;
    
}
double sqrt2( double x) // 大于2的数要转化为[0,2)区间上去
{
     double correction= 1;
     while(x>= 2)
    {
        x/= 4;
        correction*= 2;
    }
     return Tsqrt(x)*correction;
}

 

3. 平方根倒数速算法

这是牛顿迭代法的应用。 

 维基百科介绍 

牛顿迭代法是一种求方程的近似根的方法。首先要估计一个与方程的根比较靠近的数值，然后根据公式推算下一个更加近似的数值，不断重复直到可以获得满意的精度。其公式如下：

函数：y=f(x)

其一阶导数为：y'=f'(x)
则方程：f(x)=0 的第n+1个近似根为
x[n+1] = x[n] - f(x[n]) / f'(x[n])

牛顿迭代法最关键的地方在于估计第一个近似根。如果该近似根与真根足够靠近的话，那么只需要少数几次迭代，就可以得到满意的解。 现在回过头来看看如何利用牛顿法来解决我们的问题。求平方根的倒数，实际就是求方程1/(x^2)-a=0的解。将该方程按牛顿迭代法的公式展开为：
x[n+1]=1/2*x[n]*(3-a*x[n]*x[n])

 这个方法的一个关键地方还在于起始值的选取。

 具体代码如下： 

float SquareRootFloat( float number) {
     long i;
     float x, y;
     const  float f =  1.5F;
    x = number *  0.5F;
    y = number;
    i = * (  long * ) &y;
    i =  0x5f3759df - ( i >>  1 );  // 注意这一行 
    y = * (  float * ) &i;
    y = y* ( f - ( x * y * y ) );
    y = y * (f - ( x * y * y ));               
     return number * y;
}

 该方法又叫卡马克反转。其中的0x5f3759df的来历比较复杂，在维基百科中也有介绍。最后的参考中也有介绍。

最后三种方法的测试代码如下： 

View Code

 结果如下： 

第一列是随机数，第二列是库函数sqrt， <>中的是时间，y1是方法1，y2是方法2，y3是方法3

看来这三种方法时间都挺快，都小于毫秒 

参考：http://www.cnblogs.com/vagerent/archive/2007/06/25/794695.html